@lcap/nasl 0.3.10-beta → 0.3.10-beta.oom

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lcap/nasl",
   "description": "NetEase Application Specific Language",
-  "version": "0.3.10-beta",
+  "version": "0.3.10-beta.oom",
   "author": "Forrest <rainforest92@126.com>",
   "scripts": {
     "dev": "tsc -watch -p ./",
@@ -38,7 +38,6 @@
     "module-alias": "^2.2.2",
     "qs": "^6.10.1",
     "request-pre": "^0.4.3",
-    "socket.io-client": "^2.4.0",
     "uuid": "^8.3.2",
     "vue-template-compiler": "^2.6.10"
   },

package/src/types/app/App.ts

@@ -1,8 +1,6 @@
-const { io } = require('socket.io-client');
 import { excludedInJSON, immutable } from '../decorators';
-import { LEVEL_ENUM, Vertex, Service, WebService, MicroService, SERVICE_TYPE, utils, History, updateGenericTypeList, BreakPoint, BreakpointMeta, Debugger } from '..';
+import { LEVEL_ENUM, Vertex, Service, WebService, MicroService, SERVICE_TYPE, utils, History, updateGenericTypeList, vertexsMap, Entity, Structure, Enum, dataTypesMap, BaseVariable, variablesMap, updateDataTypeList } from '..';
 import appService from '../../service/app';
-import { createSocketClient, breakpointService } from '../../service/debugger/debugger';
 
 interface AppLoadAllOptions {
     asyncLoadServicesDetail?: boolean,
@@ -114,10 +112,6 @@ export class App extends Vertex {
      */
     @immutable()
     public readonly firstMicroService: MicroService = undefined;
-
-    @immutable()
-    @excludedInJSON()
-    public debuggerClient: Debugger = null;
     /**
      * 历史记录
      * 用于处理撤销重做
@@ -133,8 +127,6 @@ export class App extends Vertex {
         source && this.assign(source);
 
         this.history = new History({ app: this });
-        this.debuggerClient = new Debugger();
-        this.debuggerClient.app = this;
     }
     /**
      * 加载详情并同步 envList 信息
@@ -167,24 +159,6 @@ export class App extends Vertex {
         this.assign(result);
         return this;
     }
-
-    async loadBreakPoints() {
-        const breakpointsMeta = await breakpointService.getAllBreakPoints({
-            query: {
-                appId: this.id,
-            },
-        });
-        breakpointsMeta.forEach(async (bp: BreakpointMeta) => {
-            const bpInstance = await BreakPoint.from(bp);
-            if (bpInstance)
-                this.debuggerClient.breakPoints.push(bpInstance);
-        });
-    }
-
-    async bootDebugger() {
-        await this.debuggerClient.boot();
-    }
-
     /**
      * 加载 App 下的所有服务
      */
@@ -288,6 +262,37 @@ export class App extends Vertex {
     from(source: any) {
         return new App(source);
     }
+    /**
+     * 清理内存，避免内存泄漏
+     */
+    clear() {
+        function traverse(obj: any, callback: (obj: any) => void) {
+            if(typeof obj !== 'object' || obj === null) return;
+            if(obj.id && !vertexsMap.has(obj.id)) return;
+        
+            if(Array.isArray(obj))
+                obj.forEach((item) => {
+                    traverse(item, callback);
+                })
+            else {
+                callback(obj);
+                Object.values(obj).forEach((item) => {
+                    traverse(item, callback);
+                });
+            }
+        }
+        
+        traverse(this, (obj: any) => {
+            vertexsMap.delete(obj?.id);
+
+            if(obj instanceof Entity || obj instanceof Structure || obj instanceof Enum)
+                delete dataTypesMap[obj.schemaRef];
+
+            if(obj instanceof BaseVariable)
+                variablesMap.delete(obj.id);
+        });
+        updateDataTypeList();
+    }
 }
 
 export default App;

package/src/types/index.ts

@@ -20,17 +20,15 @@ export * from './data/dataTypes';
 export * from './data/dataTypeUtils';
 export { Interface } from './data/Interface';
 export { Category } from './data/GlobalLogicNode';
-export { default as BreakPoint, BreakpointMeta } from './logic/BreakPoint';
-export { Debugger } from './logic/Debugger';
 export { Logic } from './logic/Logic';
 export { LogicItem, LogicNode, ExpressionNode, evaluate } from './logic/LogicItem';
-export { BaseVariable, updateVariablesChildrenSchema, updateAllVariablesChildrenSchema } from './logic/BaseVariable';
+export { BaseVariable, updateVariablesChildrenSchema, updateAllVariablesChildrenSchema, variablesMap } from './logic/BaseVariable';
 export { Param } from './logic/Param';
 export { Variable } from './logic/Variable';
 export { Return } from './logic/Return';
 
 export { Page } from './page/Page';
-export { View, FrontEndsourceMap } from './page/View';
+export { View } from './page/View';
 export { ViewParam } from './page/ViewParam';
 export { ViewVariable } from './page/ViewVariable';
 export { Lifecycle } from './page/Lifecycle';

package/src/types/logic/Logic.ts

@@ -1,20 +1,10 @@
 import { immutable, excludedInJSON, circular, action } from '../decorators';
 import { config, history, utils, Vertex, LEVEL_ENUM, Interface, Param, Return, Variable, vertexsMap, typeCheck, ProcessComponent, ProcessInterface, Process, ActionOptions } from '..';
 import { logicService, paramService } from '../../service/logic';
-import { sourceMapService } from '../../service/debugger/debugger';
 import View from '../page/View';
 import { ExpressionNode, LogicItem, LogicNode } from './LogicItem';
 import { convert2SchemaType } from '../data/dataTypeUtils';
 import { isPlainObject, throttle } from 'lodash';
-interface sourceMapObj {
-    node: LogicItem,
-    classIdentify: string,
-    from: number,
-    lineFrom: number,
-    end: number
-    vertexId: string,
-    logicId: string,
-}
 import { refreshInterfaces, refreshView, refreshPages } from '../cache';
 import { BusinessCode } from '../enum';
 
@@ -149,10 +139,6 @@ export class Logic extends Vertex {
      */
     @excludedInJSON()
     public contentPromise: Promise<any> = undefined;
-    @excludedInJSON()
-    public sourceMap: {
-        [id: string]: Partial<sourceMapObj>
-    } = {};
     /**
      * 树组件的子节点字段
      */
@@ -432,16 +418,6 @@ export class Logic extends Vertex {
 
         return result as LogicItem;
     }
-    // async loadSourceMap() {
-    //     if (!logic.view) {
-    //         const result = await sourceMapService.getSourceMap({
-    //             query: {
-    //                 scopeId: this.id,
-    //             },
-    //         });
-    //         this.sourceMap = result;
-    //     }
-    // }
     /**
      * 从后端 JSON 生成规范的 Logic 对象
      */

package/src/types/logic/LogicItem.ts

@@ -1,5 +1,5 @@
 import { immutable, excludedInJSON, action } from '../decorators';
-import { config, typeCheck, utils, Vertex, LEVEL_ENUM, Logic, Schema, ActionOptions, ACTION_MODE, BreakPoint } from '..';
+import { config, typeCheck, utils, Vertex, LEVEL_ENUM, Logic, Schema, ActionOptions, ACTION_MODE } from '..';
 import { logicService } from '../../service/logic';
 import { traverse } from '../utils';
 import { vertexsMap } from '../cacheData';
@@ -89,11 +89,11 @@ export function evaluate(node: LogicNode | ExpressionNode, finalCode = true): st
 
     if (node.type === 'BinaryExpression') {
         let left: string = evaluate(<LogicNode>node.left, finalCode);
-        if (!atomicList.includes(node.left?.type as LOGIC_TYPE) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
+        if (!atomicList.includes(node.left?.type) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
             left = `(${left})`;
 
         let right: string = evaluate(<LogicNode>node.right, finalCode);
-        if (!atomicList.includes(node.right?.type as LOGIC_TYPE) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
+        if (!atomicList.includes(node.right?.type) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
             right = `(${right})`;
 
         return `${left} ${node.operator} ${right}`;
@@ -101,10 +101,10 @@ export function evaluate(node: LogicNode | ExpressionNode, finalCode = true): st
 
     if (node.type === 'LogicalExpression') {
         let left: string = evaluate(<LogicNode>node.left, finalCode);
-        if (!atomicList.includes(node.left?.type as LOGIC_TYPE) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
+        if (!atomicList.includes(node.left?.type) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
             left = `(${left})`;
         let right: string = evaluate(<LogicNode>node.right, finalCode);
-        if (!atomicList.includes(node.right?.type as LOGIC_TYPE) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
+        if (!atomicList.includes(node.right?.type) || (!finalCode && node.left?.type === LOGIC_TYPE.MemberExpression))
             right = `(${right})`;
         return `${left} ${node.operator} ${right}`;
     }
@@ -310,14 +310,6 @@ export class LogicItem extends Vertex {
     public readonly pageParamKey: any = undefined;
     @immutable()
     public readonly pageParamKeyValue: any = undefined;
-
-    /**
-        断点集合
-     */
-    @immutable()
-    @excludedInJSON()
-    public breakPoints: Array<BreakPoint> = [];
-    public temporaryBreakPoint: BreakPoint = null;
     /**
      * CallQueryComponent 对应的 structure 的 id
      */
@@ -806,8 +798,6 @@ export class LogicItem extends Vertex {
 
         if (actionOptions?.actionMode !== ACTION_MODE.undoRedo) {
             if (this.id) {
-                await this.removeAllBreakPointsOfDescendants();
-
                 const body = this.toPlainJSON();
                 /// @TODO: 不知道哪里来的 index
                 delete body.index;
@@ -1149,158 +1139,6 @@ export class LogicItem extends Vertex {
                 parentAttr: activeImage.parentAttr,
             };
     }
-
-    addBreakPointInstance(bp: BreakPoint) {
-        const finded = this.breakPoints.find((item) => item.offset === bp.offset);
-        if (!finded) {
-            this.breakPoints.push(bp);
-        }
-    }
-
-    async addBreakPoint(appId: string, offsetLine = 0) {
-        let bp = this.breakPoints.find((bp) => bp.offset === offsetLine);
-        if (bp) {
-            return bp;
-        }
-        bp = new BreakPoint();
-        await bp.create({
-            appId,
-            logicItem: this,
-            offset: offsetLine,
-        });
-        this.breakPoints.push(bp);
-        const app = config.defaultApp;
-        app.debuggerClient.breakPoints.push(bp);
-        return bp;
-    }
-
-    getBreakPointByLineNumber(lineNumber: number) {
-        return this.breakPoints.find((bp) => bp.lineNumberStart === lineNumber);
-    }
-
-    addTemperaryBreakPoint(offsetLine = 0) {
-        const bp = new BreakPoint({
-            target: this.logic && this.logic.view ? 'Frontend' : 'Backend',
-            logicItem: this,
-            logicItemId: this.id,
-            componentId: this.logic && this.logic.view && this.logic.view.id,
-            component: this.logic && this.logic.view,
-            logic: this.logic,
-            status: 'Enabled',
-            offset: offsetLine,
-            isTemporary: true,
-        });
-        bp.attachSourceMap();
-        this.temporaryBreakPoint = bp;
-        return bp;
-    }
-
-    get breakPoint(): BreakPoint {
-        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
-            return this.parent.breakPoint;
-
-        return this.breakPoints?.find((bp) => bp.offset === 0);
-    }
-
-    get hasBreakPoint(): boolean {
-        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
-            return this.parent.hasBreakPoint;
-
-        return !!(this.temporaryBreakPoint || this.breakPoint);
-    }
-
-    get isBreakPointEnabled(): boolean {
-        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
-            return this.parent.isBreakPointEnabled;
-
-        return this.breakPoint?.status === 'Enabled';
-    }
-
-    get isBreakPointDisabled(): boolean {
-        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
-            return this.parent.isBreakPointDisabled;
-
-        return this.breakPoint?.status === 'Disabled';
-    }
-
-    get isBreakPointActive(): boolean {
-        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
-            return this.parent.isBreakPointActive;
-        if (config.defaultApp.debuggerClient?.currentThread) {
-            const bp = this.temporaryBreakPoint || this.breakPoint;
-            return bp === config.defaultApp.debuggerClient?.currentThread.breakPoint;
-        }
-        return false;
-        // if (this.temporaryBreakPoint) {
-        //     return true;
-        // }
-        // return this.breakPoint === config.defaultApp.debuggerClient?.currentBreakPoint;
-    }
-
-    async setBreakPoint(offsetLine = 0) {
-        const app = config.defaultApp;
-        if (app.debuggerClient?.isConnected) {
-            const breakPoint = new BreakPoint({
-                target: this.logic && this.logic.view ? 'Frontend' : 'Backend',
-                logicItem: this,
-                logicItemId: this.id,
-                componentId: this.logic && this.logic.view && this.logic.view.id,
-                component: this.logic && this.logic.view,
-                logic: this.logic,
-                status: 'Enabled',
-                offset: offsetLine,
-            });
-            const attachResult = breakPoint.attachSourceMap();
-            if (attachResult) {
-                await app.debuggerClient.setRemoteBreakPoint(breakPoint);
-                await this.addBreakPoint(app.id, offsetLine);
-            } else {
-                this.emit('breakpointattacherror', {
-                    message: '未在sourceMap中找到'
-                });
-            }
-        } else {
-            await this.addBreakPoint(app.id, offsetLine);
-        }
-    }
-
-    async removeBreakPoint(offsetLine = 0) {
-        const app = config.defaultApp;
-        const breakPoints = this.parent?.type === 'SwitchCase' && this.parentAttr === 'test' ? this.parent.breakPoints : this.breakPoints;
-        const breakPoint = breakPoints.find((bp) => bp.offset === offsetLine);
-        await app.debuggerClient?.removeRemoteBreakPoint(breakPoint);
-        await breakPoint?.remove();
-    }
-
-    async removeAllBreakPointsOfDescendants() {
-        const promises: Array<Promise<void>> = [];
-        utils.traverse(({ node }) => {
-            if (node.breakPoints?.length > 0) {
-                node.breakPoints.forEach((bp) => {
-                    promises.push(node.removeBreakPoint(bp.offset));
-                });
-            }
-        }, { node: this }, {
-            mode: 'anyObject',
-            excludedKeySet: this.JSON_EXCLUDED_KEYS,
-        });
-        await Promise.all(promises);
-    }
-
-    async disableAllBreakPointsOfDescendants() {
-        const promises: Array<Promise<void>> = [];
-        utils.traverse(({ node }) => {
-            if (node.breakPoints?.length > 0) {
-                node.breakPoints.forEach((bp) => {
-                    promises.push(bp.disable());
-                });
-            }
-        }, { node: this }, {
-            mode: 'anyObject',
-            excludedKeySet: this.JSON_EXCLUDED_KEYS,
-        });
-        await Promise.all(promises);
-    }
 }
 
 export class LogicNode extends LogicItem {
@@ -1436,44 +1274,4 @@ export class ExpressionNode extends LogicItem {
         super();
         source && this.assign(source);
     }
-
-    addBreakPoint(appId: string, offsetLine = 0) {
-        // let switchParent = this.parent;
-        // let switchCase;
-        // while (switchParent && switchParent.type !== 'SwitchStatement') {
-        //     if (switchParent.type === 'SwitchCase') {
-        //         switchCase = switchParent;
-        //     }
-        //     switchParent = switchParent.parent;
-        // }
-
-        // switchCase 是个 logicNode，直接加好了
-        if (this.parent?.type === 'SwitchCase' && this.parentAttr === 'test')
-            return this.parent.addBreakPoint(appId, offsetLine);
-        // const index = switchParent.cases.findIndex((c) => c === switchCase);
-        // const id = switchCase.id;
-
-        // const view = this.logic.view;
-        // const sourceMap = view.sourceMap;
-        // const componentId = view.id;
-        // // const id = `${switchParent.id}-case${index}`;
-        // const map = sourceMap[id];
-        // if (map) {
-        //     const lineNumberStart = map.from + offsetLine;
-        //     let bp = this.breakPoints.find((bp) => bp.lineNumberStart === lineNumberStart);
-        //     if (bp) {
-        //         return bp;
-        //     }
-        //     bp = new BreakPoint({
-        //         lineNumberStart,
-        //         logicItem: switchCase,
-        //         logicItemId: switchCase.id,
-        //         componentId,
-        //     });
-        //     switchCase.breakPoints.push(bp);
-        //     return bp;
-        // }
-        // return null;
-        return super.addBreakPoint(appId, offsetLine);
-    }
 }