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

package/src/concepts/NewComposite__.ts

@@ -17,17 +17,18 @@ import { getNewCompositeQuickInfo, GetCode, Range } from './utils/quick-info';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
+
+import TypeAnnotation from './TypeAnnotation__';
+import Identifier from './Identifier__';
+import SelectMembers from './SelectMembers__';
+import AssignmentLine from './AssignmentLine__';
 import LogicItem from './LogicItem__';
-import type TypeAnnotation from './TypeAnnotation__';
-import type Identifier from './Identifier__';
-import type SelectMembers from './SelectMembers__';
-import type AssignmentLine from './AssignmentLine__';
 
 /**
  * 实体/（匿名）数据结构构造器
@@ -36,7 +37,11 @@ import type AssignmentLine from './AssignmentLine__';
 export class NewComposite extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'NewComposite';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
@@ -46,14 +51,13 @@ export class NewComposite extends LogicItem {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'NewComposite';
-
   /**
    * 类型
    */
   @property({
     objectRef: 'TypeAnnotation',
   })
-  typeAnnotation!: TypeAnnotation;
+  typeAnnotation: TypeAnnotation;
 
   /**
    * 左边项
@@ -88,19 +92,25 @@ export class NewComposite extends LogicItem {
   /**
    * hideProperties
    */
-  @property()
+  @property({
+    objectRef: '',
+  })
   hideProperties: boolean = false;
 
   /**
    * hideDefaults
    */
-  @property()
+  @property({
+    objectRef: '',
+  })
   hideDefaults: boolean = false;
 
   /**
    * 自动连线
    */
-  @property()
+  @property({
+    objectRef: '',
+  })
   autoConnection: boolean = true;
 
   /**
@@ -205,7 +215,7 @@ export class NewComposite extends LogicItem {
 
   getIdentifierExistingNames(excludedList: Array<Identifier> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.properties as Identifier[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.properties as Identifier[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getIdentifierUniqueName(name = 'identifier1') {
     return utils.unique(name, this.getIdentifierExistingNames(), undefined, false);
@@ -359,7 +369,7 @@ export class NewComposite extends LogicItem {
 
   getSelectMembersExistingNames(excludedList: Array<SelectMembers> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.rights as SelectMembers[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.rights as SelectMembers[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getSelectMembersUniqueName(name = 'selectMembers1') {
     return utils.unique(name, this.getSelectMembersExistingNames(), undefined, false);
@@ -515,7 +525,7 @@ export class NewComposite extends LogicItem {
     const excludedSet = new Set(excludedList);
     return ((this.assignmentLines as AssignmentLine[]) || [])
       .filter((item) => !excludedSet.has(item))
-      .map((item) => item?.name);
+      .map((item) => item.name);
   }
   getAssignmentLineUniqueName(name = 'assignmentLine1') {
     return utils.unique(name, this.getAssignmentLineExistingNames(), undefined, false);
@@ -667,62 +677,6 @@ export class NewComposite extends LogicItem {
     return node;
   }
 
-  /**
-   * 删除类型标注
-   * @param name 类型标注名称
-   */
-  removeTypeAnnotation(name: string): void;
-
-  /**
-   * 删除类型标注
-   * @param typeAnnotation 已有的类型标注实例
-   */
-  removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
-
-  removeTypeAnnotation(options: string | TypeAnnotation) {
-    let typeAnnotation: TypeAnnotation;
-    if (typeof options === 'string') {
-      typeAnnotation = this.typeAnnotation;
-      if (!typeAnnotation) {
-        throw new Error('找不到类型标注 ' + options);
-      }
-    } else {
-      typeAnnotation = options;
-    }
-    return typeAnnotation.delete();
-  }
-
-  __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
-    const parentKey = typeAnnotation.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: typeAnnotation,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = typeAnnotation.__v_raw || typeAnnotation;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除标识符
    * @param name 标识符名称
@@ -748,37 +702,6 @@ export class NewComposite extends LogicItem {
     return identifier.delete();
   }
 
-  __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logicItem,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logicItem.__v_raw || logicItem;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除选择成员
    * @param name 选择成员名称
@@ -804,37 +727,6 @@ export class NewComposite extends LogicItem {
     return selectMembers.delete();
   }
 
-  __removeSelectMembers(selectMembers: SelectMembers) {
-    const parentKey = selectMembers.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: selectMembers,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = selectMembers.__v_raw || selectMembers;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除赋值连线
    * @param name 赋值连线名称
@@ -860,41 +752,11 @@ export class NewComposite extends LogicItem {
     return assignmentLine.delete();
   }
 
-  __removeAssignmentLine(assignmentLine: AssignmentLine) {
-    const parentKey = assignmentLine.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: assignmentLine,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = assignmentLine.__v_raw || assignmentLine;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
+
   get lines() {
     return this.assignmentLines.length;
   }
@@ -1135,7 +997,7 @@ export class NewComposite extends LogicItem {
   }
 
   toUI(state?: TranslatorState, hideDetails?: boolean): string {
-    let code = '{ ';
+    let code = '新建：{ ';
     if (this.typeAnnotation) {
       const leftAssignmentMap = new Map();
       this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
@@ -1179,11 +1041,13 @@ export class NewComposite extends LogicItem {
     } else if (typeAnnotation.typeKind !== 'anonymousStructure') {
       // 实体、数据结构默认值使用new时需要改成vue.prototype才能获取到方法
       if (state?.getVuePrototype) {
-        code += `const obj = Vue.prototype.$genInitFromSchema('${typeAnnotation.sortedTypeKey
-          }', Vue.prototype.$utils['New'](${typeAnnotation.toJS(state)}));\n`;
+        code += `const obj = Vue.prototype.$genInitFromSchema('${
+          typeAnnotation.sortedTypeKey
+        }', Vue.prototype.$utils['New'](${typeAnnotation.toJS(state)}));\n`;
       } else {
-        code += `const obj = this.$genInitFromSchema('${typeAnnotation.sortedTypeKey
-          }', this.$utils['New'](${typeAnnotation.toJS(state)}));\n`;
+        code += `const obj = this.$genInitFromSchema('${
+          typeAnnotation.sortedTypeKey
+        }', this.$utils['New'](${typeAnnotation.toJS(state)}));\n`;
       }
       const rightMap = new Map();
       this.assignmentLines.forEach(({ leftIndex, rightIndex }) => {
@@ -1275,7 +1139,22 @@ export class NewComposite extends LogicItem {
         ['nasl.ui', 'nasl.interface', 'nasl.http'].includes(typeAnnotation.typeNamespace) &&
         typeAnnotation.typeKind === 'generic'
       ) {
+        const typeArguments = typeAnnotation.typeArguments || [];
+        if (typeArguments?.[0].name) {
+          // 给范型T没设置类型时报错提示
+          code += `let ${typeArguments?.[0].name} = '__IDENTIFIER__';\n`;
+        }
         code += `${indent2}let __obj = new ${typeAnnotation.typeNamespace}.${typeAnnotation.typeName}`;
+        // 新建NewComposite选择页面组件带有范型T时手动设置类型，表示范型T是否被推导
+        if (self.typeAnnotation?.inferred === false) {
+          yield* wrapForEach(typeArguments, function* warpForEachGenerator(typeArgs) {
+            if (typeArgs) {
+              code += `<`;
+              code += `${yield* typeArgs.toEmbeddedTS(shiftState(state, code, { inline: true }))}`;
+              code += `>`;
+            }
+          });
+        }
         code += '({';
         yield* wrapForEach(self.assignmentLines, function* warpForEachGenerator({ leftIndex, rightIndex }) {
           const leftSecondIndex = leftIndex[1];
@@ -1309,7 +1188,9 @@ export class NewComposite extends LogicItem {
         // 左侧properties的identifier的类型标注
         code += `${indent2}const { `;
         yield* wrapForEach(self.properties, function* warpForEachGenerator(item, index) {
-          code += yield* item.toEmbeddedTS(shiftState(state, code, { inline: true }));
+          const propertyName = yield* item.toEmbeddedTS(shiftState(state, code, { inline: true }));
+          code += propertyName;
+          code += `: __${propertyName}`;
           if (index < self.properties.length - 1) code += ', ';
         });
         code += ' } = __obj;\n';
@@ -1393,7 +1274,7 @@ export class NewComposite extends LogicItem {
           if (propertyType) {
             const typeTs = yield* propertyType.toEmbeddedTS(shiftState(state, code, { inline: true }));
             code += typeTs;
-            code += ` = ${temp};\n`;
+            code += ` = ${temp}${ts === 'null' ? ' as any' : ''};\n`;
             // 如果是字段是union类型，且赋值的是当前union允许的类型，会导致property.name类型推断成temp的类型
             code += `${indent2}${property.name} = ${property.name} as ${typeTs};\n`;
           } else {
@@ -1531,6 +1412,17 @@ export class NewComposite extends LogicItem {
     const { typeAnnotation } = this;
     if (['nasl.ui', 'nasl.interface', 'nasl.http'].includes(typeAnnotation.typeNamespace)) {
       code += `${indent2}let __obj = new ${typeAnnotation.typeNamespace}.${typeAnnotation.typeName}`;
+      const typeArguments = typeAnnotation.typeArguments || [];
+      // 新建NewComposite选择页面组件带有范型T时手动设置类型，表示范型T是否被推导
+      if (typeAnnotation?.inferred === false) {
+        yield* wrapForEach(typeArguments, function* warpForEachGenerator(typeArgs) {
+          if (typeArgs) {
+            code += `<`;
+            code += `${yield* typeArgs.toEmbeddedTS(shiftState(state, code, { inline: true }))}`;
+            code += `>`;
+          }
+        });
+      }
       code += '({';
       for (const { leftIndex, rightIndex } of this.assignmentLines) {
         const leftSecondIndex = leftIndex[1];

package/src/concepts/NewList__.ts

@@ -16,14 +16,15 @@ import { getNewCompositeQuickInfo, GetCode, Range } from './utils/quick-info';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
+
+import TypeAnnotation from './TypeAnnotation__';
 import LogicItem from './LogicItem__';
-import type TypeAnnotation from './TypeAnnotation__';
 
 /**
  * 列表构造器
@@ -32,7 +33,11 @@ import type TypeAnnotation from './TypeAnnotation__';
 export class NewList extends LogicItem {
   /** 类名 */
   static readonly ConceptName: string = 'NewList';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
@@ -42,14 +47,13 @@ export class NewList extends LogicItem {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'NewList';
-
   /**
    * 类型
    */
   @property({
     objectRef: 'TypeAnnotation',
   })
-  typeAnnotation!: TypeAnnotation;
+  typeAnnotation: TypeAnnotation;
 
   /**
    * 成员表达式
@@ -103,7 +107,7 @@ export class NewList extends LogicItem {
 
   getItemExistingNames(excludedList: Array<LogicItem> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.items as LogicItem[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.items as LogicItem[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getItemUniqueName(name = 'logicItem1') {
     return utils.unique(name, this.getItemExistingNames(), undefined, false);
@@ -255,62 +259,6 @@ export class NewList extends LogicItem {
     return node;
   }
 
-  /**
-   * 删除类型标注
-   * @param name 类型标注名称
-   */
-  removeTypeAnnotation(name: string): void;
-
-  /**
-   * 删除类型标注
-   * @param typeAnnotation 已有的类型标注实例
-   */
-  removeTypeAnnotation(typeAnnotation: TypeAnnotation): void;
-
-  removeTypeAnnotation(options: string | TypeAnnotation) {
-    let typeAnnotation: TypeAnnotation;
-    if (typeof options === 'string') {
-      typeAnnotation = this.typeAnnotation;
-      if (!typeAnnotation) {
-        throw new Error('找不到类型标注 ' + options);
-      }
-    } else {
-      typeAnnotation = options;
-    }
-    return typeAnnotation.delete();
-  }
-
-  __removeTypeAnnotation(typeAnnotation: TypeAnnotation) {
-    const parentKey = typeAnnotation.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: typeAnnotation,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = typeAnnotation.__v_raw || typeAnnotation;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   /**
    * 删除逻辑项
    * @param name 逻辑项名称
@@ -336,41 +284,11 @@ export class NewList extends LogicItem {
     return logicItem.delete();
   }
 
-  __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logicItem,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logicItem.__v_raw || logicItem;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
+
   toBrief(): string {
     let code = '';
     code += '[ ';
@@ -387,7 +305,7 @@ export class NewList extends LogicItem {
   }
 
   toUI(state?: TranslatorState, hideDetails?: boolean): string {
-    let code = '';
+    let code = '新建：';
     code += '[';
     this.items.forEach((item, index) => {
       code += item.toUI(state, hideDetails);