@lcap/nasl 1.0.0-alpha → 1.0.0-alpha.3

package/src/concepts/Namespace__.ts

@@ -6,6 +6,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import Process from './Process__';
@@ -157,7 +158,7 @@ export class Namespace extends BaseNode {
 
         getNamespaceExistingNames(excludedList: Array<Namespace> = []) {
         const excludedSet = new Set(excludedList);
-        return this.children.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.children || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getNamespaceUniqueName(name = 'namespace1') {
         return utils.unique(name, this.getNamespaceExistingNames());
@@ -192,22 +193,22 @@ export class Namespace extends BaseNode {
             namespace = Namespace.from({
                 ...namespaceOptions,
                 name: this.getNamespaceUniqueName(),
-            }, this);
+            }, this, 'children');
         } else if (typeof options === 'string') {
             namespace = Namespace.from({
                 ...namespaceOptions,
                 name: options,
-            }, this);
+            }, this, 'children');
         } else if (options instanceof Namespace) {
             options.delete(); // 同一实例不支持多处存在
             namespace = options;
+            Object.assign(namespace, relationOptions);
         } else {
             namespace = Namespace.from({
                 ...namespaceOptions,
                 ...options,
-            }, this);
+            }, this, 'children');
         }
-        Object.assign(namespace, relationOptions);
         this.children.splice(index, 0, namespace);
         return namespace;
     }
@@ -299,7 +300,7 @@ export class Namespace extends BaseNode {
 
     getProcessExistingNames(excludedList: Array<Process> = []) {
         const excludedSet = new Set(excludedList);
-        return this.processes.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.processes || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getProcessUniqueName(name = 'Process1') {
         return utils.unique(name, this.getProcessExistingNames());
@@ -334,22 +335,22 @@ export class Namespace extends BaseNode {
             process = Process.from({
                 ...processOptions,
                 name: this.getProcessUniqueName(),
-            }, this);
+            }, this, 'processes');
         } else if (typeof options === 'string') {
             process = Process.from({
                 ...processOptions,
                 name: options,
-            }, this);
+            }, this, 'processes');
         } else if (options instanceof Process) {
             options.delete(); // 同一实例不支持多处存在
             process = options;
+            Object.assign(process, relationOptions);
         } else {
             process = Process.from({
                 ...processOptions,
                 ...options,
-            }, this);
+            }, this, 'processes');
         }
-        Object.assign(process, relationOptions);
         this.processes.splice(index, 0, process);
         return process;
     }
@@ -441,7 +442,7 @@ export class Namespace extends BaseNode {
 
     getEntityExistingNames(excludedList: Array<Entity> = []) {
         const excludedSet = new Set(excludedList);
-        return this.entities.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.entities || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getEntityUniqueName(name = 'Entity1') {
         return utils.unique(name, this.getEntityExistingNames());
@@ -476,22 +477,22 @@ export class Namespace extends BaseNode {
             entity = Entity.from({
                 ...entityOptions,
                 name: this.getEntityUniqueName(),
-            }, this);
+            }, this, 'entities');
         } else if (typeof options === 'string') {
             entity = Entity.from({
                 ...entityOptions,
                 name: options,
-            }, this);
+            }, this, 'entities');
         } else if (options instanceof Entity) {
             options.delete(); // 同一实例不支持多处存在
             entity = options;
+            Object.assign(entity, relationOptions);
         } else {
             entity = Entity.from({
                 ...entityOptions,
                 ...options,
-            }, this);
+            }, this, 'entities');
         }
-        Object.assign(entity, relationOptions);
         this.entities.splice(index, 0, entity);
         return entity;
     }
@@ -583,7 +584,7 @@ export class Namespace extends BaseNode {
 
     getStructureExistingNames(excludedList: Array<Structure> = []) {
         const excludedSet = new Set(excludedList);
-        return this.structures.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.structures || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getStructureUniqueName(name = 'Structure1') {
         return utils.unique(name, this.getStructureExistingNames());
@@ -618,22 +619,22 @@ export class Namespace extends BaseNode {
             structure = Structure.from({
                 ...structureOptions,
                 name: this.getStructureUniqueName(),
-            }, this);
+            }, this, 'structures');
         } else if (typeof options === 'string') {
             structure = Structure.from({
                 ...structureOptions,
                 name: options,
-            }, this);
+            }, this, 'structures');
         } else if (options instanceof Structure) {
             options.delete(); // 同一实例不支持多处存在
             structure = options;
+            Object.assign(structure, relationOptions);
         } else {
             structure = Structure.from({
                 ...structureOptions,
                 ...options,
-            }, this);
+            }, this, 'structures');
         }
-        Object.assign(structure, relationOptions);
         this.structures.splice(index, 0, structure);
         return structure;
     }
@@ -725,7 +726,7 @@ export class Namespace extends BaseNode {
 
     getEnumExistingNames(excludedList: Array<Enum> = []) {
         const excludedSet = new Set(excludedList);
-        return this.enums.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.enums || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getEnumUniqueName(name = 'Enum1') {
         return utils.unique(name, this.getEnumExistingNames());
@@ -760,22 +761,22 @@ export class Namespace extends BaseNode {
             enumeration = Enum.from({
                 ...enumerationOptions,
                 name: this.getEnumUniqueName(),
-            }, this);
+            }, this, 'enums');
         } else if (typeof options === 'string') {
             enumeration = Enum.from({
                 ...enumerationOptions,
                 name: options,
-            }, this);
+            }, this, 'enums');
         } else if (options instanceof Enum) {
             options.delete(); // 同一实例不支持多处存在
             enumeration = options;
+            Object.assign(enumeration, relationOptions);
         } else {
             enumeration = Enum.from({
                 ...enumerationOptions,
                 ...options,
-            }, this);
+            }, this, 'enums');
         }
-        Object.assign(enumeration, relationOptions);
         this.enums.splice(index, 0, enumeration);
         return enumeration;
     }
@@ -867,7 +868,7 @@ export class Namespace extends BaseNode {
 
     getLogicExistingNames(excludedList: Array<Logic> = []) {
         const excludedSet = new Set(excludedList);
-        return this.logics.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.logics || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getLogicUniqueName(name = 'logic1') {
         return utils.unique(name, this.getLogicExistingNames());
@@ -902,22 +903,22 @@ export class Namespace extends BaseNode {
             logic = Logic.from({
                 ...logicOptions,
                 name: this.getLogicUniqueName(),
-            }, this);
+            }, this, 'logics');
         } else if (typeof options === 'string') {
             logic = Logic.from({
                 ...logicOptions,
                 name: options,
-            }, this);
+            }, this, 'logics');
         } else if (options instanceof Logic) {
             options.delete(); // 同一实例不支持多处存在
             logic = options;
+            Object.assign(logic, relationOptions);
         } else {
             logic = Logic.from({
                 ...logicOptions,
                 ...options,
-            }, this);
+            }, this, 'logics');
         }
-        Object.assign(logic, relationOptions);
         this.logics.splice(index, 0, logic);
         return logic;
     }
@@ -1009,7 +1010,7 @@ export class Namespace extends BaseNode {
 
     getFunctionExistingNames(excludedList: Array<Function> = []) {
         const excludedSet = new Set(excludedList);
-        return this.functions.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.functions || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getFunctionUniqueName(name = 'func1') {
         return utils.unique(name, this.getFunctionExistingNames());
@@ -1044,22 +1045,22 @@ export class Namespace extends BaseNode {
             func = Function.from({
                 ...funcOptions,
                 name: this.getFunctionUniqueName(),
-            }, this);
+            }, this, 'functions');
         } else if (typeof options === 'string') {
             func = Function.from({
                 ...funcOptions,
                 name: options,
-            }, this);
+            }, this, 'functions');
         } else if (options instanceof Function) {
             options.delete(); // 同一实例不支持多处存在
             func = options;
+            Object.assign(func, relationOptions);
         } else {
             func = Function.from({
                 ...funcOptions,
                 ...options,
-            }, this);
+            }, this, 'functions');
         }
-        Object.assign(func, relationOptions);
         this.functions.splice(index, 0, func);
         return func;
     }
@@ -1151,7 +1152,7 @@ export class Namespace extends BaseNode {
 
     getInterfaceExistingNames(excludedList: Array<Interface> = []) {
         const excludedSet = new Set(excludedList);
-        return this.interfaces.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.interfaces || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getInterfaceUniqueName(name = 'Interface1') {
         return utils.unique(name, this.getInterfaceExistingNames());
@@ -1186,22 +1187,22 @@ export class Namespace extends BaseNode {
             itface = Interface.from({
                 ...itfaceOptions,
                 name: this.getInterfaceUniqueName(),
-            }, this);
+            }, this, 'interfaces');
         } else if (typeof options === 'string') {
             itface = Interface.from({
                 ...itfaceOptions,
                 name: options,
-            }, this);
+            }, this, 'interfaces');
         } else if (options instanceof Interface) {
             options.delete(); // 同一实例不支持多处存在
             itface = options;
+            Object.assign(itface, relationOptions);
         } else {
             itface = Interface.from({
                 ...itfaceOptions,
                 ...options,
-            }, this);
+            }, this, 'interfaces');
         }
-        Object.assign(itface, relationOptions);
         this.interfaces.splice(index, 0, itface);
         return itface;
     }
@@ -1293,7 +1294,7 @@ export class Namespace extends BaseNode {
 
     getViewExistingNames(excludedList: Array<View> = []) {
         const excludedSet = new Set(excludedList);
-        return this.views.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.views || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getViewUniqueName(name = 'view1') {
         return utils.unique(name, this.getViewExistingNames());
@@ -1328,22 +1329,22 @@ export class Namespace extends BaseNode {
             view = View.from({
                 ...viewOptions,
                 name: this.getViewUniqueName(),
-            }, this);
+            }, this, 'views');
         } else if (typeof options === 'string') {
             view = View.from({
                 ...viewOptions,
                 name: options,
-            }, this);
+            }, this, 'views');
         } else if (options instanceof View) {
             options.delete(); // 同一实例不支持多处存在
             view = options;
+            Object.assign(view, relationOptions);
         } else {
             view = View.from({
                 ...viewOptions,
                 ...options,
-            }, this);
+            }, this, 'views');
         }
-        Object.assign(view, relationOptions);
         this.views.splice(index, 0, view);
         return view;
     }
@@ -1435,7 +1436,7 @@ export class Namespace extends BaseNode {
 
     getVariableExistingNames(excludedList: Array<Variable> = []) {
         const excludedSet = new Set(excludedList);
-        return this.variables.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.variables || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getVariableUniqueName(name = 'variable1') {
         return utils.unique(name, this.getVariableExistingNames());
@@ -1470,22 +1471,22 @@ export class Namespace extends BaseNode {
             variable = Variable.from({
                 ...variableOptions,
                 name: this.getVariableUniqueName(),
-            }, this);
+            }, this, 'variables');
         } else if (typeof options === 'string') {
             variable = Variable.from({
                 ...variableOptions,
                 name: options,
-            }, this);
+            }, this, 'variables');
         } else if (options instanceof Variable) {
             options.delete(); // 同一实例不支持多处存在
             variable = options;
+            Object.assign(variable, relationOptions);
         } else {
             variable = Variable.from({
                 ...variableOptions,
                 ...options,
-            }, this);
+            }, this, 'variables');
         }
-        Object.assign(variable, relationOptions);
         this.variables.splice(index, 0, variable);
         return variable;
     }
@@ -1577,7 +1578,7 @@ export class Namespace extends BaseNode {
 
     getViewComponentExistingNames(excludedList: Array<ViewComponent> = []) {
         const excludedSet = new Set(excludedList);
-        return this.viewComponents.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.viewComponents || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getViewComponentUniqueName(name = 'viewComponent1') {
         return utils.unique(name, this.getViewComponentExistingNames());
@@ -1612,22 +1613,22 @@ export class Namespace extends BaseNode {
             viewComponent = ViewComponent.from({
                 ...viewComponentOptions,
                 name: this.getViewComponentUniqueName(),
-            }, this);
+            }, this, 'viewComponents');
         } else if (typeof options === 'string') {
             viewComponent = ViewComponent.from({
                 ...viewComponentOptions,
                 name: options,
-            }, this);
+            }, this, 'viewComponents');
         } else if (options instanceof ViewComponent) {
             options.delete(); // 同一实例不支持多处存在
             viewComponent = options;
+            Object.assign(viewComponent, relationOptions);
         } else {
             viewComponent = ViewComponent.from({
                 ...viewComponentOptions,
                 ...options,
-            }, this);
+            }, this, 'viewComponents');
         }
-        Object.assign(viewComponent, relationOptions);
         this.viewComponents.splice(index, 0, viewComponent);
         return viewComponent;
     }
@@ -1719,7 +1720,7 @@ export class Namespace extends BaseNode {
 
     getProcessComponentExistingNames(excludedList: Array<ProcessComponent> = []) {
         const excludedSet = new Set(excludedList);
-        return this.processComponents.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.processComponents || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getProcessComponentUniqueName(name = 'processComponent1') {
         return utils.unique(name, this.getProcessComponentExistingNames());
@@ -1754,22 +1755,22 @@ export class Namespace extends BaseNode {
             processComponent = ProcessComponent.from({
                 ...processComponentOptions,
                 name: this.getProcessComponentUniqueName(),
-            }, this);
+            }, this, 'processComponents');
         } else if (typeof options === 'string') {
             processComponent = ProcessComponent.from({
                 ...processComponentOptions,
                 name: options,
-            }, this);
+            }, this, 'processComponents');
         } else if (options instanceof ProcessComponent) {
             options.delete(); // 同一实例不支持多处存在
             processComponent = options;
+            Object.assign(processComponent, relationOptions);
         } else {
             processComponent = ProcessComponent.from({
                 ...processComponentOptions,
                 ...options,
-            }, this);
+            }, this, 'processComponents');
         }
-        Object.assign(processComponent, relationOptions);
         this.processComponents.splice(index, 0, processComponent);
         return processComponent;
     }

package/src/concepts/NullLiteral__.ts

@@ -1,4 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
+import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -8,6 +9,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import LogicItem from './LogicItem__';
@@ -23,12 +25,6 @@ export class NullLiteral extends LogicItem {
     @property()
     concept: 'NullLiteral' = 'NullLiteral';
 
-    /**
-     * kind
-     */
-    @property()
-    kind: string = 'Expression';
-
     
 
     /**
@@ -55,12 +51,15 @@ export class NullLiteral extends LogicItem {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+    toVue(options?: ElementToVueOptions): string {
+        return 'null';
+    }
 
-    toUI(state?: TranslatorState): string {
+    toUI(): string {
         return 'null';
     }
 
-    toJS(state?: TranslatorState): string {
+    toJS(): string {
         return 'null';
     }
 

package/src/concepts/NumericLiteral__.ts

@@ -1,4 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
+import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -8,6 +9,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import TypeAnnotation from './TypeAnnotation__';
@@ -24,12 +26,6 @@ export class NumericLiteral extends LogicItem {
     @property()
     concept: 'NumericLiteral' = 'NumericLiteral';
 
-    /**
-     * kind
-     */
-    @property()
-    kind: string = 'Expression';
-
     /**
      * 字面量的值
      */
@@ -116,12 +112,18 @@ export class NumericLiteral extends LogicItem {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
-    toUI(state?: TranslatorState): string {
+
+    toVue(options?: ElementToVueOptions): string {
+        const code = this.value ? String(this.value) : '';
+        return code;
+    }
+
+    toUI(): string {
         const code = this.value ? String(this.value) : '';
         return code;
     }
 
-    toJS(state?: TranslatorState): string {
+    toJS(): string {
         const code = this.value ? String(this.value) : '';
         return code;
     }

package/src/concepts/Param__.ts

@@ -15,6 +15,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import TypeAnnotation from './TypeAnnotation__';
@@ -251,12 +252,12 @@ export class Param extends BaseNode {
      */
     completionChildren: Array<EntityProperty | StructureProperty> = undefined;
 
-    toUI(state?: TranslatorState): string {
-        return this.name;
-    }
-
     toJS(state?: TranslatorState): string {
-        return this.name;
+        if (this.view) {
+            return `${this.name} = ${this.name} !== undefined ? ${this.name} : this.$genInitFromSchema(${JSON.stringify(this.typeAnnotation)}, this.$route.query.hasOwnProperty('${this.name}') ? this.$route.query.${this.name} : ${JSON.stringify(this.defaultValue)}, true)`;
+        } else {
+            return '';
+        }
     }
 
     @withSourceMap()
@@ -296,7 +297,7 @@ export class Param extends BaseNode {
         const object = {
             typeAnnotation,
             // 处理下拉属性
-            completionChildren: this.getSelectRef(),
+            // completionChildren: this.getSelectRef(),
         };
         return this.update({
             ...object,
@@ -317,7 +318,7 @@ export class Param extends BaseNode {
     /**
      * 是否可编辑
      * */
-    get nodeReadonly() {
+    get readonly() {
         return !!this.module;
     }
 

package/src/concepts/Point__.ts

@@ -6,6 +6,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 

package/src/concepts/ProcessComponent__.ts

@@ -6,6 +6,7 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property } from '../decorators';
 
 import * as utils from '../utils';
+import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import classMap from '../common/classMap';
 import Attribute from './Attribute__';
@@ -101,7 +102,7 @@ export class ProcessComponent extends BaseNode {
 
         getAttributeExistingNames(excludedList: Array<Attribute> = []) {
         const excludedSet = new Set(excludedList);
-        return this.attrs.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.attrs || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getAttributeUniqueName(name = 'attribute1') {
         return utils.unique(name, this.getAttributeExistingNames());
@@ -136,22 +137,22 @@ export class ProcessComponent extends BaseNode {
             attribute = Attribute.from({
                 ...attributeOptions,
                 name: this.getAttributeUniqueName(),
-            }, this);
+            }, this, 'attrs');
         } else if (typeof options === 'string') {
             attribute = Attribute.from({
                 ...attributeOptions,
                 name: options,
-            }, this);
+            }, this, 'attrs');
         } else if (options instanceof Attribute) {
             options.delete(); // 同一实例不支持多处存在
             attribute = options;
+            Object.assign(attribute, relationOptions);
         } else {
             attribute = Attribute.from({
                 ...attributeOptions,
                 ...options,
-            }, this);
+            }, this, 'attrs');
         }
-        Object.assign(attribute, relationOptions);
         this.attrs.splice(index, 0, attribute);
         return attribute;
     }
@@ -243,7 +244,7 @@ export class ProcessComponent extends BaseNode {
 
     getLogicExistingNames(excludedList: Array<Logic> = []) {
         const excludedSet = new Set(excludedList);
-        return this.logics.filter((item) => !excludedSet.has(item)).map((item) => item.name);
+        return (this.logics || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getLogicUniqueName(name = 'logic1') {
         return utils.unique(name, this.getLogicExistingNames());
@@ -278,22 +279,22 @@ export class ProcessComponent extends BaseNode {
             logic = Logic.from({
                 ...logicOptions,
                 name: this.getLogicUniqueName(),
-            }, this);
+            }, this, 'logics');
         } else if (typeof options === 'string') {
             logic = Logic.from({
                 ...logicOptions,
                 name: options,
-            }, this);
+            }, this, 'logics');
         } else if (options instanceof Logic) {
             options.delete(); // 同一实例不支持多处存在
             logic = options;
+            Object.assign(logic, relationOptions);
         } else {
             logic = Logic.from({
                 ...logicOptions,
                 ...options,
-            }, this);
+            }, this, 'logics');
         }
-        Object.assign(logic, relationOptions);
         this.logics.splice(index, 0, logic);
         return logic;
     }