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

package/out/concepts/Frontend__.d.ts

@@ -1,9 +1,11 @@
 import { TranslatorState } from '../translator';
 import { AssetsInfo } from './App__';
+import Variable from './Variable__';
 import { Params } from '../common/EventEmitter';
 import BaseNode from '../common/BaseNode';
+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__';
@@ -39,14 +41,18 @@ export declare class Frontend extends BaseNode {
      * 制品应用图标
      */
     documentIcon: string;
+    /**
+     * 元素绑定事件列表
+     */
+    bindEvents: Array<BindEvent>;
     /**
      * 页面列表
      */
     views: Array<View>;
     /**
-     * 变量列表
+     * 前端全局变量列表
      */
-    variables: Array<Variable>;
+    variables: Array<FrontendVariable>;
     /**
      * 主题配置
      */
@@ -55,6 +61,14 @@ export declare class Frontend extends BaseNode {
      * 扩展组件列表（兼容老版）
      */
     componentDependencies: Array<Module>;
+    /**
+     * 全局缩放开关
+     */
+    globalScaleEnabled: boolean;
+    /**
+     * 画布宽度
+     */
+    canvasWidth: number;
     /**
      * 祖先 App
      */
@@ -90,6 +104,83 @@ export declare class Frontend extends BaseNode {
      * 设置制品应用图标
      */
     setDocumentIcon(documentIcon: string): void;
+    /**
+     * 设置全局缩放开关
+     */
+    setGlobalScaleEnabled(globalScaleEnabled: boolean): void;
+    /**
+     * 设置画布宽度
+     */
+    setCanvasWidth(canvasWidth: number): void;
+    getBindEventExistingNames(excludedList?: Array<BindEvent>): string[];
+    getBindEventUniqueName(name?: string): string;
+    /**
+    * 插入元素绑定事件
+    * @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;
+    /**
+     * 插入元素绑定事件
+     * @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;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    _addBindEvent(name?: string): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    _addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    _addBindEvent(bindEvent: BindEvent): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @internal
+     * @param name 元素绑定事件名称，如果不填会自动生成一个唯一名称
+     */
+    addBindEvent(name?: string): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @param bindEventOptions 元素绑定事件参数
+     */
+    addBindEvent(bindEventOptions: Partial<BindEvent>): BindEvent;
+    /**
+     * 添加元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    addBindEvent(bindEvent: BindEvent): BindEvent;
     getViewExistingNames(excludedList?: Array<View>): string[];
     getViewUniqueName(name?: string): string;
     /**
@@ -159,75 +250,75 @@ export declare class Frontend extends BaseNode {
      * @param view 已有的页面实例
      */
     addView(view: View): View;
-    getVarExistingNames(excludedList?: Array<Variable>): string[];
-    getVariableUniqueName(name?: string): string;
+    getVarExistingNames(excludedList?: Array<FrontendVariable>): string[];
+    getFrontendVariableUniqueName(name?: string): string;
     /**
-    * 插入变量
+    * 插入前端全局变量
     * @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;
     /**
-     * 插入变量
-     * @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;
     /**
-     * 添加变量
+     * 添加前端全局变量
      * @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;
     /**
-     * 添加变量
+     * 添加前端全局变量
      * @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;
     getModuleExistingNames(excludedList?: Array<Module>): string[];
     getModuleUniqueName(name?: string): string;
     /**
@@ -298,6 +389,17 @@ export declare class Frontend extends BaseNode {
      */
     addModule(module: Module): Module;
     /**
+    * 删除元素绑定事件
+    * @param name 元素绑定事件名称
+    */
+    removeBindEvent(name: string): void;
+    /**
+     * 删除元素绑定事件
+     * @param bindEvent 已有的元素绑定事件实例
+     */
+    removeBindEvent(bindEvent: BindEvent): void;
+    __removeBindEvent(bindEvent: BindEvent): Params;
+    /**
     * 删除页面
     * @param name 页面名称
     */
@@ -309,15 +411,15 @@ export declare class Frontend extends BaseNode {
     removeView(view: View): void;
     __removeView(view: View): 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(variable: Variable): Params;
     /**
     * 删除主题
@@ -349,6 +451,7 @@ export declare class Frontend extends BaseNode {
     findViewByPath(path: string): View;
     findViewByName(name: string): View;
     genThemeCSS(): string;
+    getTsNamespace(): string;
     getNamespace(): string;
     /**
      * 生成宿主语言的文件路径
@@ -369,5 +472,6 @@ export declare class Frontend extends BaseNode {
     get basePath(): string;
     genCustomAssetsInfo(prefix: string): AssetsInfo;
     getExtensionsCallbackLogics(): string[];
+    get defaultCanvasWidth(): 1440 | 375;
 }
 export default Frontend;

package/out/concepts/Frontend__.js

@@ -39,8 +39,9 @@ const decorators_1 = require("../decorators");
 const utils = __importStar(require("../utils"));
 const BaseNode_1 = __importDefault(require("../common/BaseNode"));
 const classMap_1 = __importDefault(require("../common/classMap"));
+const BindEvent__1 = __importDefault(require("./BindEvent__"));
 const View__1 = __importDefault(require("./View__"));
-const Variable__1 = __importDefault(require("./Variable__"));
+const FrontendVariable__1 = __importDefault(require("./FrontendVariable__"));
 const Theme__1 = __importDefault(require("./Theme__"));
 const Module__1 = __importDefault(require("./Module__"));
 /**
@@ -75,12 +76,16 @@ let Frontend = Frontend_1 = class Frontend extends BaseNode_1.default {
      * 制品应用图标
      */
     documentIcon = undefined;
+    /**
+     * 元素绑定事件列表
+     */
+    bindEvents = [];
     /**
      * 页面列表
      */
     views = [];
     /**
-     * 变量列表
+     * 前端全局变量列表
      */
     variables = [];
     /**
@@ -91,6 +96,14 @@ let Frontend = Frontend_1 = class Frontend extends BaseNode_1.default {
      * 扩展组件列表（兼容老版）
      */
     componentDependencies = [];
+    /**
+     * 全局缩放开关
+     */
+    globalScaleEnabled = false;
+    /**
+     * 画布宽度
+     */
+    canvasWidth = 0;
     /**
      * 祖先 App
      */
@@ -178,6 +191,88 @@ let Frontend = Frontend_1 = class Frontend extends BaseNode_1.default {
             ...object,
         });
     }
+    /**
+     * 设置全局缩放开关
+     */
+    setGlobalScaleEnabled(globalScaleEnabled) {
+        const object = {
+            globalScaleEnabled,
+        };
+        this.update({
+            ...object,
+        });
+    }
+    /**
+     * 设置画布宽度
+     */
+    setCanvasWidth(canvasWidth) {
+        const object = {
+            canvasWidth,
+        };
+        this.update({
+            ...object,
+        });
+    }
+    getBindEventExistingNames(excludedList = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.bindEvents || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    }
+    getBindEventUniqueName(name = 'bindEvent1') {
+        return utils.unique(name, this.getBindEventExistingNames(), undefined, false);
+    }
+    _insertBindEventAt(options, index) {
+        const bindEventOptions = {};
+        const relationOptions = { parentNode: this, parentKey: 'bindEvents' };
+        let bindEvent;
+        if (!options) {
+            bindEvent = BindEvent__1.default.from({
+                ...bindEventOptions,
+                name: this.getBindEventUniqueName(),
+            }, this, 'bindEvents');
+        }
+        else if (typeof options === 'string') {
+            bindEvent = BindEvent__1.default.from({
+                ...bindEventOptions,
+                name: options,
+            }, this, 'bindEvents');
+        }
+        else if (options instanceof BindEvent__1.default) {
+            options.ensureDelete(); // 同一实例不支持多处存在
+            bindEvent = options;
+            Object.assign(bindEvent, relationOptions);
+        }
+        else {
+            bindEvent = BindEvent__1.default.from({
+                ...bindEventOptions,
+                ...options,
+            }, this, 'bindEvents');
+        }
+        this.bindEvents.splice(index, 0, bindEvent);
+        return bindEvent;
+    }
+    insertBindEventAt(options, index) {
+        const node = this._insertBindEventAt(options, index);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'bindEvents',
+        });
+        return node;
+    }
+    _addBindEvent(options) {
+        const index = this.bindEvents.length;
+        return this._insertBindEventAt(options, index);
+    }
+    addBindEvent(options) {
+        const node = this._addBindEvent(options);
+        const index = this.bindEvents.indexOf(node);
+        node.create({
+            index,
+            parentNode: this,
+            parentKey: 'bindEvents',
+        });
+        return node;
+    }
     getViewExistingNames(excludedList = []) {
         const excludedSet = new Set(excludedList);
         return (this.views || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -242,41 +337,41 @@ let Frontend = Frontend_1 = class Frontend extends BaseNode_1.default {
         const excludedSet = new Set(excludedList);
         return (this.variables || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
-    getVariableUniqueName(name = 'variable1') {
+    getFrontendVariableUniqueName(name = 'frontendVariable1') {
         return utils.unique(name, this.getVarExistingNames(), undefined, true);
     }
-    _insertVariableAt(options, index) {
-        const variableOptions = {};
+    _insertFrontendVariableAt(options, index) {
+        const frontendVariableOptions = {};
         const relationOptions = { parentNode: this, parentKey: 'variables' };
-        let variable;
+        let frontendVariable;
         if (!options) {
-            variable = Variable__1.default.from({
-                ...variableOptions,
-                name: this.getVariableUniqueName(),
+            frontendVariable = FrontendVariable__1.default.from({
+                ...frontendVariableOptions,
+                name: this.getFrontendVariableUniqueName(),
             }, this, 'variables');
         }
         else if (typeof options === 'string') {
-            variable = Variable__1.default.from({
-                ...variableOptions,
+            frontendVariable = FrontendVariable__1.default.from({
+                ...frontendVariableOptions,
                 name: options,
             }, this, 'variables');
         }
-        else if (options instanceof Variable__1.default) {
+        else if (options instanceof FrontendVariable__1.default) {
             options.ensureDelete(); // 同一实例不支持多处存在
-            variable = options;
-            Object.assign(variable, relationOptions);
+            frontendVariable = options;
+            Object.assign(frontendVariable, relationOptions);
         }
         else {
-            variable = Variable__1.default.from({
-                ...variableOptions,
+            frontendVariable = FrontendVariable__1.default.from({
+                ...frontendVariableOptions,
                 ...options,
             }, this, 'variables');
         }
-        this.variables.splice(index, 0, variable);
-        return variable;
+        this.variables.splice(index, 0, frontendVariable);
+        return frontendVariable;
     }
-    insertVariableAt(options, index) {
-        const node = this._insertVariableAt(options, index);
+    insertFrontendVariableAt(options, index) {
+        const node = this._insertFrontendVariableAt(options, index);
         node.create({
             index,
             parentNode: this,
@@ -284,12 +379,12 @@ let Frontend = Frontend_1 = class Frontend extends BaseNode_1.default {
         });
         return node;
     }
-    _addVariable(options) {
+    _addFrontendVariable(options) {
         const index = this.variables.length;
-        return this._insertVariableAt(options, index);
+        return this._insertFrontendVariableAt(options, index);
     }
-    addVariable(options) {
-        const node = this._addVariable(options);
+    addFrontendVariable(options) {
+        const node = this._addFrontendVariable(options);
         const index = this.variables.indexOf(node);
         node.create({
             index,
@@ -358,6 +453,42 @@ let Frontend = Frontend_1 = class Frontend extends BaseNode_1.default {
         });
         return node;
     }
+    removeBindEvent(options) {
+        let bindEvent;
+        if (typeof options === 'string') {
+            bindEvent = this.bindEvents.find((item) => item.name === options);
+            if (!bindEvent) {
+                throw new Error('找不到元素绑定事件 ' + options);
+            }
+        }
+        else {
+            bindEvent = options;
+        }
+        return bindEvent.delete();
+    }
+    __removeBindEvent(bindEvent) {
+        const parentKey = bindEvent.parentKey;
+        const params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: bindEvent,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray(this[parentKey])) {
+                const index = this[parentKey].indexOf(bindEvent);
+                ~index && this[parentKey].splice(index, 1);
+                params.index = index;
+            }
+            else if (this[parentKey] === bindEvent) {
+                params.index = 0;
+                this[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
     removeView(options) {
         let view;
         if (typeof options === 'string') {
@@ -394,18 +525,18 @@ let Frontend = Frontend_1 = class Frontend extends BaseNode_1.default {
         }
         return params;
     }
-    removeVariable(options) {
-        let variable;
+    removeFrontendVariable(options) {
+        let frontendVariable;
         if (typeof options === 'string') {
-            variable = this.variables.find((item) => item.name === options);
-            if (!variable) {
-                throw new Error('找不到变量 ' + options);
+            frontendVariable = this.variables.find((item) => item.name === options);
+            if (!frontendVariable) {
+                throw new Error('找不到前端全局变量 ' + options);
             }
         }
         else {
-            variable = options;
+            frontendVariable = options;
         }
-        return variable.delete();
+        return frontendVariable.delete();
     }
     __removeVariable(variable) {
         const parentKey = variable.parentKey;
@@ -537,6 +668,19 @@ let Frontend = Frontend_1 = class Frontend extends BaseNode_1.default {
             ${keys.map((key) => `    ${key}: ${this.theme?.variableMap[key]};`).join('\n')}
         }`;
     }
+    getTsNamespace() {
+        if (this.parentNode && this.parentNode.getNamespace) {
+            const parentNamespace = this.parentNode.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.getNamespace) {
             const parentNamespace = this.parentNode.getNamespace();
@@ -635,6 +779,9 @@ let Frontend = Frontend_1 = class Frontend extends BaseNode_1.default {
         });
         return Array.from(new Set(resultLogics));
     }
+    get defaultCanvasWidth() {
+        return this.type === 'pc' ? 1440 : 375;
+    }
 };
 __decorate([
     (0, decorators_1.property)()
@@ -657,11 +804,14 @@ __decorate([
 __decorate([
     (0, decorators_1.property)()
 ], Frontend.prototype, "documentIcon", void 0);
+__decorate([
+    (0, decorators_1.property)('BindEvent')
+], Frontend.prototype, "bindEvents", void 0);
 __decorate([
     (0, decorators_1.property)('View')
 ], Frontend.prototype, "views", void 0);
 __decorate([
-    (0, decorators_1.property)('Variable')
+    (0, decorators_1.property)('FrontendVariable')
 ], Frontend.prototype, "variables", void 0);
 __decorate([
     (0, decorators_1.property)('Theme')
@@ -669,6 +819,12 @@ __decorate([
 __decorate([
     (0, decorators_1.property)('Module')
 ], Frontend.prototype, "componentDependencies", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Frontend.prototype, "globalScaleEnabled", void 0);
+__decorate([
+    (0, decorators_1.property)()
+], Frontend.prototype, "canvasWidth", void 0);
 __decorate([
     (0, translator_1.withSourceMap)()
 ], Frontend.prototype, "toEmbeddedTS", null);