@lcap/nasl 3.4.0-alpha.1 → 3.4.0-beta.1

package/src/concepts/Connector__.ts

@@ -1,18 +1,18 @@
-//= ===============================================================================
+//================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-//= ===============================================================================
-import { v4 as uuidv4 } from 'uuid';
+//================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property } from '../decorators';
+import { concept, excludedInJSON, property, className } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
-import classMap from '../common/classMap';
 import Param from './Param__';
 import Logic from './Logic__';
 import ConnectorTrigger from './ConnectorTrigger__';
 import Structure from './Structure__';
+import Namespace from './Namespace__';
 import Module from './Module__';
 import View from './View__';
 import ProcessElement from './ProcessElement__';
@@ -23,48 +23,67 @@ import Process from './Process__';
 /**
  * 连接器
  */
+@className
 @concept('连接器')
+// @ts-ignore
 export class Connector extends Module {
+  /** 类名 */
+  static readonly ConceptName = 'Connector';
+
   /**
    * 产品概念
    */
-  @property()
-  concept: 'Connector' = 'Connector';
+  // @ts-ignore
+  readonly concept!: 'Connector';
 
   /**
    * 连接器名称
    */
   @property()
-  name: string = undefined;
+  // @ts-ignore
+  name!: string;
 
   /**
    * connectorKind
    */
   @property()
-  connectorKind: string = undefined;
+  // @ts-ignore
+  connectorKind!: string;
 
   /**
    * 输入参数列表
    */
-  @property('Param')
+  @property({
+    objectRef: 'Param',
+    isArray: true,
+  })
   properties: Array<Param> = [];
 
   /**
    * 逻辑列表
    */
-  @property('Logic')
+  @property({
+    objectRef: 'Logic',
+    isArray: true,
+  })
   logics: Array<Logic> = [];
 
   /**
-   * 连接器Trigger列表
+   * 连接器触发器列表
    */
-  @property('ConnectorTrigger')
+  @property({
+    objectRef: 'ConnectorTrigger',
+    isArray: true,
+  })
   triggers: Array<ConnectorTrigger> = [];
 
   /**
    * 数据结构列表
    */
-  @property('Structure')
+  @property({
+    objectRef: 'Structure',
+    isArray: true,
+  })
   structures: Array<Structure> = [];
 
   /**
@@ -72,19 +91,41 @@ export class Connector extends Module {
    */
   @property()
   // @ts-ignore
-  compilerInfoMap: Map<string, string> = undefined;
+  compilerInfoMap!: Map<string, string>;
 
   /**
    * createLogic
    */
-  @property('Logic')
-  createLogic: undefined = undefined;
+  @property({
+    objectRef: 'Logic',
+  })
+  // @ts-ignore
+  createLogic!: undefined;
 
   /**
    * testConnectorLogic
    */
-  @property('Logic')
-  testConnectorLogic: undefined = undefined;
+  @property({
+    objectRef: 'Logic',
+  })
+  // @ts-ignore
+  testConnectorLogic!: undefined;
+
+  /**
+   * 预览图
+   */
+  @property()
+  // @ts-ignore
+  previewImg!: string;
+
+  /**
+   * 命名空间列表
+   */
+  @property({
+    objectRef: 'Namespace',
+    isArray: true,
+  })
+  namespaces: Array<Namespace> = [];
 
   /**
    * 祖先 Module
@@ -92,35 +133,30 @@ export class Connector extends Module {
   get module() {
     return this.getAncestor('Module') as Module;
   }
-
   /**
    * 祖先 App
    */
   get app() {
     return this.getAncestor('App') as App;
   }
-
   /**
    * 祖先 View
    */
   get view() {
     return this.getAncestor('View') as View;
   }
-
   /**
    * 祖先 Frontend
    */
   get frontend() {
     return this.getAncestor('Frontend') as Frontend;
   }
-
   /**
    * 祖先 ProcessElement
    */
   get processElement() {
     return this.getAncestor('ProcessElement') as ProcessElement;
   }
-
   /**
    * 祖先 Process
    */
@@ -132,16 +168,11 @@ export class Connector extends Module {
    * @param source 需要合并的部分参数
    */
   constructor(source?: Partial<Connector>) {
-    // @ts-ignore
-    source = { ...Connector.getDefaultOptions(), ...source };
+    source = Object.assign({}, Connector.getDefaultOptions(), source);
     super(source as any);
     super.subConstructor(source);
   }
 
-  getClassName() {
-    return 'Connector';
-  }
-
   static from(source: any, parentNode?: any, parentKey?: string): Connector {
     return super.from(source, parentNode, parentKey) as Connector;
   }
@@ -196,7 +227,7 @@ export class Connector extends Module {
   }
 
   /**
-   * 设置连接器Trigger列表
+   * 设置连接器触发器列表
    */
   setTriggers(triggers: Array<ConnectorTrigger>) {
     const object = {
@@ -255,11 +286,34 @@ export class Connector extends Module {
     });
   }
 
+  /**
+   * 设置预览图
+   */
+  setPreviewImg(previewImg: string) {
+    const object = {
+      previewImg,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
+  /**
+   * 设置命名空间列表
+   */
+  setNamespaces(namespaces: Array<Namespace>) {
+    const object = {
+      namespaces,
+    };
+    this.update({
+      ...object,
+    });
+  }
+
   getParamExistingNames(excludedList: Array<Param> = []) {
     const excludedSet = new Set(excludedList);
     return ((this.properties as Param[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-
   getParamUniqueName(name = 'param1') {
     return utils.unique(name, this.getParamExistingNames(), undefined, false);
   }
@@ -296,7 +350,7 @@ export class Connector extends Module {
           name: this.getParamUniqueName(),
         },
         this,
-        'properties'
+        'properties',
       );
     } else if (typeof options === 'string') {
       param = Param.from(
@@ -305,7 +359,7 @@ export class Connector extends Module {
           name: options,
         },
         this,
-        'properties'
+        'properties',
       );
     } else if (options instanceof Param) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -318,7 +372,7 @@ export class Connector extends Module {
           ...options,
         },
         this,
-        'properties'
+        'properties',
       );
     }
     this.properties.splice(index, 0, param);
@@ -413,7 +467,6 @@ export class Connector extends Module {
     const excludedSet = new Set(excludedList);
     return ((this.logics as Logic[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-
   getLogicUniqueName(name = 'logic1') {
     return utils.unique(name, this.getLogicExistingNames(), undefined, false);
   }
@@ -450,7 +503,7 @@ export class Connector extends Module {
           name: this.getLogicUniqueName(),
         },
         this,
-        'logics'
+        'logics',
       );
     } else if (typeof options === 'string') {
       logic = Logic.from(
@@ -459,7 +512,7 @@ export class Connector extends Module {
           name: options,
         },
         this,
-        'logics'
+        'logics',
       );
     } else if (options instanceof Logic) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -472,7 +525,7 @@ export class Connector extends Module {
           ...options,
         },
         this,
-        'logics'
+        'logics',
       );
     }
     this.logics.splice(index, 0, logic);
@@ -565,31 +618,32 @@ export class Connector extends Module {
 
   getConnectorTriggerExistingNames(excludedList: Array<ConnectorTrigger> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.triggers as ConnectorTrigger[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+    return ((this.triggers as ConnectorTrigger[]) || [])
+      .filter((item) => !excludedSet.has(item))
+      .map((item) => item.name);
   }
-
   getConnectorTriggerUniqueName(name = 'connectorTrigger1') {
     return utils.unique(name, this.getConnectorTriggerExistingNames(), undefined, false);
   }
 
   /**
-   * 插入连接器Trigger
+   * 插入连接器触发器
    * @internal
-   * @param name 连接器Trigger名称，如果不填会自动生成一个唯一名称
+   * @param name 连接器触发器名称，如果不填会自动生成一个唯一名称
    */
   _insertConnectorTriggerAt(name: string, index: number): ConnectorTrigger;
 
   /**
-   * 插入连接器Trigger
+   * 插入连接器触发器
    * @internal
-   * @param connectorTriggerOptions 连接器Trigger参数
+   * @param connectorTriggerOptions 连接器触发器参数
    */
   _insertConnectorTriggerAt(connectorTriggerOptions: Partial<ConnectorTrigger>, index: number): ConnectorTrigger;
 
   /**
-   * 插入连接器Trigger
+   * 插入连接器触发器
    * @internal
-   * @param connectorTrigger 已有的连接器Trigger实例
+   * @param connectorTrigger 已有的连接器触发器实例
    */
   _insertConnectorTriggerAt(connectorTrigger: ConnectorTrigger, index: number): ConnectorTrigger;
 
@@ -604,7 +658,7 @@ export class Connector extends Module {
           name: this.getConnectorTriggerUniqueName(),
         },
         this,
-        'triggers'
+        'triggers',
       );
     } else if (typeof options === 'string') {
       connectorTrigger = ConnectorTrigger.from(
@@ -613,7 +667,7 @@ export class Connector extends Module {
           name: options,
         },
         this,
-        'triggers'
+        'triggers',
       );
     } else if (options instanceof ConnectorTrigger) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -626,7 +680,7 @@ export class Connector extends Module {
           ...options,
         },
         this,
-        'triggers'
+        'triggers',
       );
     }
     this.triggers.splice(index, 0, connectorTrigger);
@@ -634,20 +688,20 @@ export class Connector extends Module {
   }
 
   /**
-   * 插入连接器Trigger
-   * @param name 连接器Trigger名称，如果不填会自动生成一个唯一名称
+   * 插入连接器触发器
+   * @param name 连接器触发器名称，如果不填会自动生成一个唯一名称
    */
   insertConnectorTriggerAt(name: string, index: number): ConnectorTrigger;
 
   /**
-   * 插入连接器Trigger
-   * @param connectorTriggerOptions 连接器Trigger参数
+   * 插入连接器触发器
+   * @param connectorTriggerOptions 连接器触发器参数
    */
   insertConnectorTriggerAt(connectorTriggerOptions: Partial<ConnectorTrigger>, index: number): ConnectorTrigger;
 
   /**
-   * 插入连接器Trigger
-   * @param connectorTrigger 已有的连接器Trigger实例
+   * 插入连接器触发器
+   * @param connectorTrigger 已有的连接器触发器实例
    */
   insertConnectorTriggerAt(connectorTrigger: ConnectorTrigger, index: number): ConnectorTrigger;
 
@@ -662,23 +716,23 @@ export class Connector extends Module {
   }
 
   /**
-   * 添加连接器Trigger
+   * 添加连接器触发器
    * @internal
-   * @param name 连接器Trigger名称，如果不填会自动生成一个唯一名称
+   * @param name 连接器触发器名称，如果不填会自动生成一个唯一名称
    */
   _addConnectorTrigger(name?: string): ConnectorTrigger;
 
   /**
-   * 添加连接器Trigger
+   * 添加连接器触发器
    * @internal
-   * @param connectorTriggerOptions 连接器Trigger参数
+   * @param connectorTriggerOptions 连接器触发器参数
    */
   _addConnectorTrigger(connectorTriggerOptions: Partial<ConnectorTrigger>): ConnectorTrigger;
 
   /**
-   * 添加连接器Trigger
+   * 添加连接器触发器
    * @internal
-   * @param connectorTrigger 已有的连接器Trigger实例
+   * @param connectorTrigger 已有的连接器触发器实例
    */
   _addConnectorTrigger(connectorTrigger: ConnectorTrigger): ConnectorTrigger;
 
@@ -688,21 +742,21 @@ export class Connector extends Module {
   }
 
   /**
-   * 添加连接器Trigger
+   * 添加连接器触发器
    * @internal
-   * @param name 连接器Trigger名称，如果不填会自动生成一个唯一名称
+   * @param name 连接器触发器名称，如果不填会自动生成一个唯一名称
    */
   addConnectorTrigger(name?: string): ConnectorTrigger;
 
   /**
-   * 添加连接器Trigger
-   * @param connectorTriggerOptions 连接器Trigger参数
+   * 添加连接器触发器
+   * @param connectorTriggerOptions 连接器触发器参数
    */
   addConnectorTrigger(connectorTriggerOptions: Partial<ConnectorTrigger>): ConnectorTrigger;
 
   /**
-   * 添加连接器Trigger
-   * @param connectorTrigger 已有的连接器Trigger实例
+   * 添加连接器触发器
+   * @param connectorTrigger 已有的连接器触发器实例
    */
   addConnectorTrigger(connectorTrigger: ConnectorTrigger): ConnectorTrigger;
 
@@ -721,7 +775,6 @@ export class Connector extends Module {
     const excludedSet = new Set(excludedList);
     return ((this.structures as Structure[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
-
   getStructureUniqueName(name = 'structure1') {
     return utils.unique(name, this.getStructureExistingNames(), undefined, false);
   }
@@ -758,7 +811,7 @@ export class Connector extends Module {
           name: this.getStructureUniqueName(),
         },
         this,
-        'structures'
+        'structures',
       );
     } else if (typeof options === 'string') {
       structure = Structure.from(
@@ -767,7 +820,7 @@ export class Connector extends Module {
           name: options,
         },
         this,
-        'structures'
+        'structures',
       );
     } else if (options instanceof Structure) {
       options.ensureDelete(); // 同一实例不支持多处存在
@@ -780,7 +833,7 @@ export class Connector extends Module {
           ...options,
         },
         this,
-        'structures'
+        'structures',
       );
     }
     this.structures.splice(index, 0, structure);
@@ -871,6 +924,159 @@ export class Connector extends Module {
     return node;
   }
 
+  getNamespaceExistingNames(excludedList: Array<Namespace> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.namespaces as Namespace[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
+  }
+  getNamespaceUniqueName(name = 'namespace1') {
+    return utils.unique(name, this.getNamespaceExistingNames(), undefined, false);
+  }
+
+  /**
+   * 插入命名空间
+   * @internal
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
+   */
+  _insertNamespaceAt(name: string, index: number): Namespace;
+
+  /**
+   * 插入命名空间
+   * @internal
+   * @param namespaceOptions 命名空间参数
+   */
+  _insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
+
+  /**
+   * 插入命名空间
+   * @internal
+   * @param namespace 已有的命名空间实例
+   */
+  _insertNamespaceAt(namespace: Namespace, index: number): Namespace;
+
+  _insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
+    const namespaceOptions: any = {};
+    const relationOptions = { parentNode: this, parentKey: 'namespaces' };
+    let namespace: Namespace;
+    if (!options) {
+      namespace = Namespace.from(
+        {
+          ...namespaceOptions,
+          name: this.getNamespaceUniqueName(),
+        },
+        this,
+        'namespaces',
+      );
+    } else if (typeof options === 'string') {
+      namespace = Namespace.from(
+        {
+          ...namespaceOptions,
+          name: options,
+        },
+        this,
+        'namespaces',
+      );
+    } else if (options instanceof Namespace) {
+      options.ensureDelete(); // 同一实例不支持多处存在
+      namespace = options;
+      Object.assign(namespace, relationOptions);
+    } else {
+      namespace = Namespace.from(
+        {
+          ...namespaceOptions,
+          ...options,
+        },
+        this,
+        'namespaces',
+      );
+    }
+    this.namespaces.splice(index, 0, namespace);
+    return namespace;
+  }
+
+  /**
+   * 插入命名空间
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
+   */
+  insertNamespaceAt(name: string, index: number): Namespace;
+
+  /**
+   * 插入命名空间
+   * @param namespaceOptions 命名空间参数
+   */
+  insertNamespaceAt(namespaceOptions: Partial<Namespace>, index: number): Namespace;
+
+  /**
+   * 插入命名空间
+   * @param namespace 已有的命名空间实例
+   */
+  insertNamespaceAt(namespace: Namespace, index: number): Namespace;
+
+  insertNamespaceAt(options: string | Partial<Namespace> | Namespace, index: number) {
+    const node = this._insertNamespaceAt(options as any, index);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'namespaces',
+    });
+    return node;
+  }
+
+  /**
+   * 添加命名空间
+   * @internal
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
+   */
+  _addNamespace(name?: string): Namespace;
+
+  /**
+   * 添加命名空间
+   * @internal
+   * @param namespaceOptions 命名空间参数
+   */
+  _addNamespace(namespaceOptions: Partial<Namespace>): Namespace;
+
+  /**
+   * 添加命名空间
+   * @internal
+   * @param namespace 已有的命名空间实例
+   */
+  _addNamespace(namespace: Namespace): Namespace;
+
+  _addNamespace(options?: string | Partial<Namespace> | Namespace) {
+    const index = this.namespaces.length;
+    return this._insertNamespaceAt(options as any, index);
+  }
+
+  /**
+   * 添加命名空间
+   * @internal
+   * @param name 命名空间名称，如果不填会自动生成一个唯一名称
+   */
+  addNamespace(name?: string): Namespace;
+
+  /**
+   * 添加命名空间
+   * @param namespaceOptions 命名空间参数
+   */
+  addNamespace(namespaceOptions: Partial<Namespace>): Namespace;
+
+  /**
+   * 添加命名空间
+   * @param namespace 已有的命名空间实例
+   */
+  addNamespace(namespace: Namespace): Namespace;
+
+  addNamespace(options?: string | Partial<Namespace> | Namespace) {
+    const node = this._addNamespace(options as any);
+    const index = this.namespaces.indexOf(node);
+    node.create({
+      index,
+      parentNode: this,
+      parentKey: 'namespaces',
+    });
+    return node;
+  }
+
   /**
    * 删除输入参数
    * @param name 输入参数名称
@@ -888,7 +1094,7 @@ export class Connector extends Module {
     if (typeof options === 'string') {
       param = (this.properties as Param[]).find((item) => item.name === options);
       if (!param) {
-        throw new Error(`找不到输入参数 ${options}`);
+        throw new Error('找不到输入参数 ' + options);
       }
     } else {
       param = options;
@@ -897,7 +1103,7 @@ export class Connector extends Module {
   }
 
   __removeParam(param: Param) {
-    const { parentKey } = param;
+    const parentKey = param.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -936,7 +1142,7 @@ export class Connector extends Module {
     if (typeof options === 'string') {
       logic = (this.logics as Logic[]).find((item) => item.name === options);
       if (!logic) {
-        throw new Error(`找不到逻辑 ${options}`);
+        throw new Error('找不到逻辑 ' + options);
       }
     } else {
       logic = options;
@@ -961,7 +1167,7 @@ export class Connector extends Module {
     if (typeof options === 'string') {
       createLogic = this.createLogic;
       if (!createLogic) {
-        throw new Error(`找不到逻辑 ${options}`);
+        throw new Error('找不到逻辑 ' + options);
       }
     } else {
       createLogic = options;
@@ -986,7 +1192,7 @@ export class Connector extends Module {
     if (typeof options === 'string') {
       testConnectorLogic = this.testConnectorLogic;
       if (!testConnectorLogic) {
-        throw new Error(`找不到逻辑 ${options}`);
+        throw new Error('找不到逻辑 ' + options);
       }
     } else {
       testConnectorLogic = options;
@@ -995,7 +1201,7 @@ export class Connector extends Module {
   }
 
   __removeLogic(logic: Logic) {
-    const { parentKey } = logic;
+    const parentKey = logic.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -1018,14 +1224,14 @@ export class Connector extends Module {
   }
 
   /**
-   * 删除连接器Trigger
-   * @param name 连接器Trigger名称
+   * 删除连接器触发器
+   * @param name 连接器触发器名称
    */
   removeConnectorTrigger(name: string): void;
 
   /**
-   * 删除连接器Trigger
-   * @param connectorTrigger 已有的连接器Trigger实例
+   * 删除连接器触发器
+   * @param connectorTrigger 已有的连接器触发器实例
    */
   removeConnectorTrigger(connectorTrigger: ConnectorTrigger): void;
 
@@ -1034,7 +1240,7 @@ export class Connector extends Module {
     if (typeof options === 'string') {
       connectorTrigger = (this.triggers as ConnectorTrigger[]).find((item) => item.name === options);
       if (!connectorTrigger) {
-        throw new Error(`找不到连接器Trigger ${options}`);
+        throw new Error('找不到连接器触发器 ' + options);
       }
     } else {
       connectorTrigger = options;
@@ -1043,7 +1249,7 @@ export class Connector extends Module {
   }
 
   __removeConnectorTrigger(connectorTrigger: ConnectorTrigger) {
-    const { parentKey } = connectorTrigger;
+    const parentKey = connectorTrigger.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -1082,7 +1288,7 @@ export class Connector extends Module {
     if (typeof options === 'string') {
       structure = (this.structures as Structure[]).find((item) => item.name === options);
       if (!structure) {
-        throw new Error(`找不到数据结构 ${options}`);
+        throw new Error('找不到数据结构 ' + options);
       }
     } else {
       structure = options;
@@ -1091,7 +1297,7 @@ export class Connector extends Module {
   }
 
   __removeStructure(structure: Structure) {
-    const { parentKey } = structure;
+    const parentKey = structure.parentKey;
     const params: Params = {
       parentNode: this,
       parentKey,
@@ -1113,23 +1319,91 @@ export class Connector extends Module {
     return params;
   }
 
-  //= ===============================================================================
+  /**
+   * 删除命名空间
+   * @param name 命名空间名称
+   */
+  removeNamespace(name: string): void;
+
+  /**
+   * 删除命名空间
+   * @param namespace 已有的命名空间实例
+   */
+  removeNamespace(namespace: Namespace): void;
+
+  removeNamespace(options: string | Namespace) {
+    let namespace: Namespace;
+    if (typeof options === 'string') {
+      namespace = (this.namespaces as Namespace[]).find((item) => item.name === options);
+      if (!namespace) {
+        throw new Error('找不到命名空间 ' + options);
+      }
+    } else {
+      namespace = options;
+    }
+    return namespace.delete();
+  }
+
+  __removeNamespace(namespace: Namespace) {
+    const parentKey = namespace.parentKey;
+    const params: Params = {
+      parentNode: this,
+      parentKey,
+      index: -1,
+      object: null,
+      oldObject: namespace,
+    };
+    if (parentKey) {
+      params.parentKey = parentKey;
+      if (Array.isArray((this as any)[parentKey])) {
+        const index = (this as any)[parentKey].indexOf(namespace);
+        ~index && (this as any)[parentKey].splice(index, 1);
+        params.index = index;
+      } else if ((this as any)[parentKey] === namespace) {
+        params.index = 0;
+        (this as any)[parentKey] = undefined;
+      }
+    }
+    return params;
+  }
+
+  //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
-  //= ===============================================================================
+  //================================================================================
 
   getActions() {
+    // 自定义连接器有分组的概念
+    if (this.connectorKind === 'app') {
+      return this.namespaces.map((namespace) => {
+        return {
+          title: namespace.title,
+          name: namespace.name,
+          expanded: true,
+          unselectable: true, // 自定义属性。用于标注当前选项是否可以被选择
+          children: namespace.logics,
+        };
+      });
+    }
     return this.logics;
   }
-  //= ===============================================================================
+
+  getNamespaceExistingTitles(excludedList: Array<Namespace> = []) {
+    const excludedSet = new Set(excludedList);
+    return ((this.namespaces as Namespace[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.title);
+  }
+
+  getNamespaceUniqueTitle(name = '分组1') {
+    return utils.unique(name, this.getNamespaceExistingTitles(), undefined, false);
+  }
+  //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
-  //= ===============================================================================
+  //================================================================================
 }
 
-classMap.Connector = Connector;
 export default Connector;
-//= ===============================================================================
+//================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
 // 自动生成的代码已结束。下面可以手动编写。
-//= ===============================================================================
+//================================================================================