@lcap/nasl 2.22.0-beta.5 → 3.0.0-beta.1

package/src/concepts/Frontend__.ts

@@ -1,6 +1,7 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
 import { AssetsInfo } from './App__';
 import Namespace from './Namespace__';
+import Variable from './Variable__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -13,8 +14,9 @@ import * as utils from '../utils';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
+import BindEvent from './BindEvent__';
 import View from './View__';
-import Variable from './Variable__';
+import FrontendVariable from './FrontendVariable__';
 import Theme from './Theme__';
 import Module from './Module__';
 import App from './App__';
@@ -66,6 +68,12 @@ export class Frontend extends BaseNode {
     @property()
     documentIcon: string = undefined;
 
+    /**
+     * 元素绑定事件列表
+     */
+    @property('BindEvent')
+    bindEvents: Array<BindEvent> = [];
+
     /**
      * 页面列表
      */
@@ -73,10 +81,10 @@ export class Frontend extends BaseNode {
     views: Array<View> = [];
 
     /**
-     * 变量列表
+     * 前端全局变量列表
      */
-    @property('Variable')
-    variables: Array<Variable> = [];
+    @property('FrontendVariable')
+    variables: Array<FrontendVariable> = [];
 
     /**
      * 主题配置
@@ -90,6 +98,18 @@ export class Frontend extends BaseNode {
     @property('Module')
     componentDependencies: Array<Module> = [];
 
+    /**
+     * 全局缩放开关
+     */
+    @property()
+    globalScaleEnabled: boolean = false;
+
+    /**
+     * 画布宽度
+     */
+    @property()
+    canvasWidth: number = 0;
+
     /**
      * 祖先 App
      */
@@ -185,7 +205,172 @@ export class Frontend extends BaseNode {
         });
     }
 
-        getViewExistingNames(excludedList: Array<View> = []) {
+    /**
+     * 设置全局缩放开关
+     */
+    setGlobalScaleEnabled(globalScaleEnabled: boolean) {
+        const object = {
+            globalScaleEnabled,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    /**
+     * 设置画布宽度
+     */
+    setCanvasWidth(canvasWidth: number) {
+        const object = {
+            canvasWidth,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    getBindEventExistingNames(excludedList: Array<BindEvent> = []) {
+        const excludedSet = new Set(excludedList);
+        return ((this.bindEvents as BindEvent[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getBindEventUniqueName(name = 'bindEvent1') {
+        return utils.unique(name, this.getBindEventExistingNames(), undefined, false);
+    }
+
+    /**
+    * 插入元素绑定事件
+    * @internal
+    * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+    */
+    _insertBindEventAt(name: string, index: number): BindEvent;
+
+    /**
+    * 插入元素绑定事件
+    * @internal
+    * @param bindEventOptions 元素绑定事件参数
+    */
+    _insertBindEventAt(bindEventOptions: Partial<BindEvent>, index: number): BindEvent;
+
+    /**
+    * 插入元素绑定事件
+    * @internal
+    * @param bindEvent 已有的元素绑定事件实例
+    */
+    _insertBindEventAt(bindEvent: BindEvent, index: number): BindEvent;
+
+    _insertBindEventAt(options: string | Partial<BindEvent> | BindEvent, index: number) {
+        const bindEventOptions: any = {};
+        const relationOptions = { parentNode: this, parentKey: 'bindEvents' };
+        let bindEvent: BindEvent;
+        if (!options) {
+            bindEvent = BindEvent.from({
+                ...bindEventOptions,
+                name: this.getBindEventUniqueName(),
+            }, this, 'bindEvents');
+        } else if (typeof options === 'string') {
+            bindEvent = BindEvent.from({
+                ...bindEventOptions,
+                name: options,
+            }, this, 'bindEvents');
+        } else if (options instanceof BindEvent) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            bindEvent = options;
+            Object.assign(bindEvent, relationOptions);
+        } else {
+            bindEvent = BindEvent.from({
+                ...bindEventOptions,
+                ...options,
+            }, this, 'bindEvents');
+        }
+        this.bindEvents.splice(index, 0, bindEvent);
+        return bindEvent;
+    }
+
+    /**
+     * 插入元素绑定事件
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    insertBindEventAt(name: string, index: number): BindEvent;
+
+    /**
+     * 插入元素绑定事件
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    insertBindEventAt(bindEventOptions: Partial<BindEvent>, index: number): BindEvent;
+
+    /**
+     * 插入元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    insertBindEventAt(bindEvent: BindEvent, index: number): BindEvent;
+
+    insertBindEventAt(options: string | Partial<BindEvent> | BindEvent, index: number) {
+        const node = this._insertBindEventAt(options as any, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'bindEvents',
+        });
+        return node;
+    }
+
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    _addBindEvent(name?: string): BindEvent;
+
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    _addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
+
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    _addBindEvent(bindEvent: BindEvent): BindEvent;
+
+    _addBindEvent(options?: string | Partial<BindEvent> | BindEvent) {
+        const index = this.bindEvents.length;
+        return this._insertBindEventAt(options as any, index);
+    }
+
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    addBindEvent(name?: string): BindEvent;
+
+    /**
+     * 添加元素绑定事件
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
+
+    /**
+     * 添加元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    addBindEvent(bindEvent: BindEvent): BindEvent;
+
+    addBindEvent(options?: string | Partial<BindEvent> | BindEvent) {
+        const node = this._addBindEvent(options as any);
+        const index = this.bindEvents.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'bindEvents',
+        });
+        return node;
+    }
+
+    getViewExistingNames(excludedList: Array<View> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.views as View[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -326,84 +511,83 @@ export class Frontend extends BaseNode {
         return node;
     }
 
-
-    getVarExistingNames(excludedList: Array<Variable> = []) {
+    getVarExistingNames(excludedList: Array<FrontendVariable> = []) {
         const excludedSet = new Set(excludedList);
-        return ((this.variables as Variable[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return ((this.variables as FrontendVariable[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
-    getVariableUniqueName(name = 'variable1') {
+    getFrontendVariableUniqueName(name = 'frontendVariable1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, true);
     }
 
     /**
-    * 插入变量
+    * 插入前端全局变量
     * @internal
-    * @param name 变量名称，如果不填会自动生成一个唯一名称
+    * @param name 前端全局变量名称，如果不填会自动生成一个唯一名称
     */
-    _insertVariableAt(name: string, index: number): Variable;
+    _insertFrontendVariableAt(name: string, index: number): FrontendVariable;
 
     /**
-    * 插入变量
+    * 插入前端全局变量
     * @internal
-    * @param variableOptions 变量参数
+    * @param frontendVariableOptions 前端全局变量参数
     */
-    _insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
+    _insertFrontendVariableAt(frontendVariableOptions: Partial<FrontendVariable>, index: number): FrontendVariable;
 
     /**
-    * 插入变量
+    * 插入前端全局变量
     * @internal
-    * @param variable 已有的变量实例
+    * @param frontendVariable 已有的前端全局变量实例
     */
-    _insertVariableAt(variable: Variable, index: number): Variable;
+    _insertFrontendVariableAt(frontendVariable: FrontendVariable, index: number): FrontendVariable;
 
-    _insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
-        const variableOptions: any = {};
+    _insertFrontendVariableAt(options: string | Partial<FrontendVariable> | FrontendVariable, index: number) {
+        const frontendVariableOptions: any = {};
         const relationOptions = { parentNode: this, parentKey: 'variables' };
-        let variable: Variable;
+        let frontendVariable: FrontendVariable;
         if (!options) {
-            variable = Variable.from({
-                ...variableOptions,
-                name: this.getVariableUniqueName(),
+            frontendVariable = FrontendVariable.from({
+                ...frontendVariableOptions,
+                name: this.getFrontendVariableUniqueName(),
             }, this, 'variables');
         } else if (typeof options === 'string') {
-            variable = Variable.from({
-                ...variableOptions,
+            frontendVariable = FrontendVariable.from({
+                ...frontendVariableOptions,
                 name: options,
             }, this, 'variables');
-        } else if (options instanceof Variable) {
+        } else if (options instanceof FrontendVariable) {
             options.ensureDelete(); // 同一实例不支持多处存在
-            variable = options;
-            Object.assign(variable, relationOptions);
+            frontendVariable = options;
+            Object.assign(frontendVariable, relationOptions);
         } else {
-            variable = Variable.from({
-                ...variableOptions,
+            frontendVariable = FrontendVariable.from({
+                ...frontendVariableOptions,
                 ...options,
             }, this, 'variables');
         }
-        this.variables.splice(index, 0, variable);
-        return variable;
+        this.variables.splice(index, 0, frontendVariable);
+        return frontendVariable;
     }
 
     /**
-     * 插入变量
-     * @param name 变量名称，如果不填会自动生成一个唯一名称
+     * 插入前端全局变量
+     * @param name 前端全局变量名称，如果不填会自动生成一个唯一名称
      */
-    insertVariableAt(name: string, index: number): Variable;
+    insertFrontendVariableAt(name: string, index: number): FrontendVariable;
 
     /**
-     * 插入变量
-     * @param variableOptions 变量参数
+     * 插入前端全局变量
+     * @param frontendVariableOptions 前端全局变量参数
      */
-    insertVariableAt(variableOptions: Partial<Variable>, index: number): Variable;
+    insertFrontendVariableAt(frontendVariableOptions: Partial<FrontendVariable>, index: number): FrontendVariable;
 
     /**
-     * 插入变量
-     * @param variable 已有的变量实例
+     * 插入前端全局变量
+     * @param frontendVariable 已有的前端全局变量实例
      */
-    insertVariableAt(variable: Variable, index: number): Variable;
+    insertFrontendVariableAt(frontendVariable: FrontendVariable, index: number): FrontendVariable;
 
-    insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
-        const node = this._insertVariableAt(options as any, index);
+    insertFrontendVariableAt(options: string | Partial<FrontendVariable> | FrontendVariable, index: number) {
+        const node = this._insertFrontendVariableAt(options as any, index);
         node.create({
             index,
             parentNode: this,
@@ -413,52 +597,52 @@ export class Frontend extends BaseNode {
     }
 
     /**
-     * 添加变量
+     * 添加前端全局变量
      * @internal
-     * @param name 变量名称，如果不填会自动生成一个唯一名称
+     * @param name 前端全局变量名称，如果不填会自动生成一个唯一名称
      */
-    _addVariable(name?: string): Variable;
+    _addFrontendVariable(name?: string): FrontendVariable;
 
     /**
-     * 添加变量
+     * 添加前端全局变量
      * @internal
-     * @param variableOptions 变量参数
+     * @param frontendVariableOptions 前端全局变量参数
      */
-    _addVariable(variableOptions: Partial<Variable>): Variable;
+    _addFrontendVariable(frontendVariableOptions: Partial<FrontendVariable>): FrontendVariable;
 
     /**
-     * 添加变量
+     * 添加前端全局变量
      * @internal
-     * @param variable 已有的变量实例
+     * @param frontendVariable 已有的前端全局变量实例
      */
-    _addVariable(variable: Variable): Variable;
+    _addFrontendVariable(frontendVariable: FrontendVariable): FrontendVariable;
 
-    _addVariable(options?: string | Partial<Variable> | Variable) {
+    _addFrontendVariable(options?: string | Partial<FrontendVariable> | FrontendVariable) {
         const index = this.variables.length;
-        return this._insertVariableAt(options as any, index);
+        return this._insertFrontendVariableAt(options as any, index);
     }
 
     /**
-     * 添加变量
+     * 添加前端全局变量
      * @internal
-     * @param name 变量名称，如果不填会自动生成一个唯一名称
+     * @param name 前端全局变量名称，如果不填会自动生成一个唯一名称
      */
-    addVariable(name?: string): Variable;
+    addFrontendVariable(name?: string): FrontendVariable;
 
     /**
-     * 添加变量
-     * @param variableOptions 变量参数
+     * 添加前端全局变量
+     * @param frontendVariableOptions 前端全局变量参数
      */
-    addVariable(variableOptions: Partial<Variable>): Variable;
+    addFrontendVariable(frontendVariableOptions: Partial<FrontendVariable>): FrontendVariable;
 
     /**
-     * 添加变量
-     * @param variable 已有的变量实例
+     * 添加前端全局变量
+     * @param frontendVariable 已有的前端全局变量实例
      */
-    addVariable(variable: Variable): Variable;
+    addFrontendVariable(frontendVariable: FrontendVariable): FrontendVariable;
 
-    addVariable(options?: string | Partial<Variable> | Variable) {
-        const node = this._addVariable(options as any);
+    addFrontendVariable(options?: string | Partial<FrontendVariable> | FrontendVariable) {
+        const node = this._addFrontendVariable(options as any);
         const index = this.variables.indexOf(node);
         node.create({
             index,
@@ -468,7 +652,6 @@ export class Frontend extends BaseNode {
         return node;
     }
 
-
     getModuleExistingNames(excludedList: Array<Module> = []) {
         const excludedSet = new Set(excludedList);
         return ((this.componentDependencies as Module[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -610,8 +793,53 @@ export class Frontend extends BaseNode {
         return node;
     }
 
+    /**
+    * 删除元素绑定事件
+    * @param name 元素绑定事件名称
+    */
+    removeBindEvent(name: string): void;
 
-    
+    /**
+     * 删除元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    removeBindEvent(bindEvent: BindEvent): void;
+
+    removeBindEvent(options: string | BindEvent) {
+        let bindEvent: BindEvent;
+        if (typeof options === 'string') {
+            bindEvent = (this.bindEvents as BindEvent[]).find((item) => item.name === options);
+            if (!bindEvent) {
+                throw new Error('找不到元素绑定事件 ' + options);
+            }
+        } else {
+            bindEvent = options;
+        }
+        return bindEvent.delete();
+    }
+
+    __removeBindEvent(bindEvent: BindEvent) {
+        const parentKey = bindEvent.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: bindEvent,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(bindEvent);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === bindEvent) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
 
     /**
     * 删除页面
@@ -661,31 +889,29 @@ export class Frontend extends BaseNode {
         return params;
     }
 
-
-
     /**
-    * 删除变量
-    * @param name 变量名称
+    * 删除前端全局变量
+    * @param name 前端全局变量名称
     */
-    removeVariable(name: string): void;
+    removeFrontendVariable(name: string): void;
 
     /**
-     * 删除变量
-     * @param variable 已有的变量实例
+     * 删除前端全局变量
+     * @param frontendVariable 已有的前端全局变量实例
      */
-    removeVariable(variable: Variable): void;
+    removeFrontendVariable(frontendVariable: FrontendVariable): void;
 
-    removeVariable(options: string | Variable) {
-        let variable: Variable;
+    removeFrontendVariable(options: string | FrontendVariable) {
+        let frontendVariable: FrontendVariable;
         if (typeof options === 'string') {
-            variable = (this.variables as Variable[]).find((item) => item.name === options);
-            if (!variable) {
-                throw new Error('找不到变量 ' + options);
+            frontendVariable = (this.variables as FrontendVariable[]).find((item) => item.name === options);
+            if (!frontendVariable) {
+                throw new Error('找不到前端全局变量 ' + options);
             }
         } else {
-            variable = options;
+            frontendVariable = options;
         }
-        return variable.delete();
+        return frontendVariable.delete();
     }
 
     __removeVariable(variable: Variable) {
@@ -711,8 +937,6 @@ export class Frontend extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除主题
     * @param name 主题名称
@@ -761,8 +985,6 @@ export class Frontend extends BaseNode {
         return params;
     }
 
-
-
     /**
     * 删除模块
     * @param name 模块名称
@@ -852,6 +1074,18 @@ export class Frontend extends BaseNode {
             ${keys.map((key) => `    ${key}: ${this.theme?.variableMap[key]};`).join('\n')}
         }`;
     }
+    getTsNamespace() {
+        if (this.parentNode && (this.parentNode as Namespace).getNamespace) {
+            const parentNamespace = (this.parentNode as Namespace).getNamespace();
+            const parentName = this.parentNode.name;
+            const arr = [parentNamespace];
+            if (this.parentNode.concept !== 'App' && parentName) {
+                arr.push(parentName);
+            }
+            return `${arr.join('.')}.frontends`;
+        } else
+            throw new Error('无法获取命名空间，请设置 parentNode！');
+    }
 
     getNamespace() {
         if (this.parentNode && (this.parentNode as Namespace).getNamespace) {
@@ -953,13 +1187,42 @@ export class Frontend extends BaseNode {
     }
 
     getExtensionsCallbackLogics() {
-        let resultLogics:string[] = [];
-        this.views.forEach((item:View) => {
+        let resultLogics: string[] = [];
+        this.views.forEach((item: View) => {
             resultLogics = [...resultLogics, ...item.getViewCallLogics()];
         });
         return Array.from(new Set(resultLogics));
     }
 
+    get defaultCanvasWidth() {
+        return this.type === 'pc' ? 1440 : 375;
+    }
+    /**
+    * 获取当前页面下所有elements上bindEvents下的logic
+    */
+    // elementLogicRoot: any[] = [];
+
+    // getElementLogicRoot() {
+    //     const logics: Array<Logic> = [];
+    //     // 页面上的绑定的事件
+    //     this.bindEvents.forEach((bindEvent) => {
+    //         bindEvent.logics.forEach((logic) => {
+    //             // 声明周期没有event
+    //             logics.push(logic);
+    //         });
+    //     });
+    //     if (logics.length) {
+    //         const expanded = (this.elementLogicRoot.length && this.elementLogicRoot[0].expanded) || false;
+    //         this.elementLogicRoot = [{
+    //             concept: 'elementLogicRoot',
+    //             expanded,
+    //             children: logics,
+    //         }];
+    //     } else {
+    //         this.elementLogicRoot = [];
+    //     }
+    // }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Function__.ts

@@ -969,7 +969,7 @@ export class Function extends BaseNode {
         let code = '';
         code += '(';
         this.params.forEach((param, index) => {
-            code += param.toJS(shiftState(state, code));
+            code += param.name;
             if (index !== this.params.length - 1) {
                 code += ',';
             }

package/src/concepts/Identifier__.ts

@@ -75,10 +75,10 @@ export class Identifier extends LogicItem {
     globalDataMap: {
         [name: string]: boolean;
     } = {
-        $route: true,
-        $global: true,
-        $refs: true,
-    };
+            $route: true,
+            $global: true,
+            $refs: true,
+        };
 
     isEnum() {
         return findConceptKeyWordByNamespace(this.namespace) === 'enums';
@@ -209,7 +209,7 @@ export class Identifier extends LogicItem {
         }
 
         // 全局变量在不是页面的地方放置，就会报错
-        if (this.namespace?.startsWith('app.frontends') && this.namespace?.endsWith('variables') && !this.view) {
+        if (this.namespace?.startsWith('app.frontends') && this.namespace?.endsWith('variables') && !this.frontend) {
             return '__FRONTENDVARIABLES__';
         }
 

package/src/concepts/Interface__.ts

@@ -28,7 +28,7 @@ export class Interface extends BaseNode {
      * 产品概念
      */
     @property()
-    concept: 'Interface' = 'Interface';
+    concept: 'Interface' | 'AuthInterface' = 'Interface';
 
     /**
      * 接口名称