@lcap/nasl 1.0.0-alpha.9 → 1.0.2

package/src/concepts/StringLiteral__.ts

@@ -58,63 +58,45 @@ export class StringLiteral extends LogicItem {
     //================================================================================
     toVue(options?: ElementToVueOptions): string {
         let code = '';
-        if (this.value) {
-            if (!this.value.includes("'"))
-                code += `'${this.value}'`;
-            else if (!this.value.includes('"'))
-                code += `"${this.value}"`;
-            else if (!this.value.includes('`'))
-                code += `\`${this.value}\``;
-            else
-                code += `'${this.value.replace(/'/g, "\\'")}'`;
+        if (typeof this.value === 'string') {
+            code = `'${this.value}'`;
+            if (options?.finalCode !== false) {
+                code = `'${this.value.replace(/['"`\\]/g, (m) => {
+                    const escape = '\\\\';
+                    if (m === '\\') {
+                        return `${escape}${escape}`;
+                    } else {
+                        return `${escape}${m}`;
+                    }
+                })}'`;
+            }
         }
         return code;
     }
 
     toUI(): string {
         let code = '';
-        if (this.value) {
-            if (!this.value.includes("'"))
-                code += `'${this.value}'`;
-            else if (!this.value.includes('"'))
-                code += `"${this.value}"`;
-            else if (!this.value.includes('`'))
-                code += `\`${this.value}\``;
-            else
-                code += `'${this.value.replace(/'/g, "\\'")}'`;
+        if (typeof this.value === 'string') {
+            code = `'${this.value}'`;
         }
         return code;
     }
 
     toJS(): string {
-        let code = '';
-        if (this.value) {
-            if (!this.value.includes("'"))
-                code += `'${this.value}'`;
-            else if (!this.value.includes('"'))
-                code += `"${this.value}"`;
-            else if (!this.value.includes('`'))
-                code += `\`${this.value}\``;
-            else
-                code += `'${this.value.replace(/'/g, "\\'")}'`;
+        let code = ``;
+        if (typeof this.value === 'string') {
+            code += `'${this.value.replace(/['"`\\]/g, (m) => `\\${m}`)}'`;
         }
         return code;
     }
 
     @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
+    toEmbeddedTS(state?: TranslatorState, isRequired?: boolean): string {
         let code = '';
-        if (this.value) {
-            if (!this.value.includes("'"))
-                code += `'${this.value}'`;
-            else if (!this.value.includes('"'))
-                code += `"${this.value}"`;
-            else if (!this.value.includes('`'))
-                code += `\`${this.value}\``;
-            else
-                code += `'${this.value.replace(/'/g, "\\'")}'`;
+        if (typeof this.value === 'string') {
+            code += `'StringLiteral'`;
         } else {
-            code += '__IDENTIFIER__';
+            code += isRequired ? '__IDENTIFIER__' : `''`;
         }
         return code;
     }

package/src/concepts/StructureProperty__.ts

@@ -2,7 +2,7 @@ import { dataTypesMap } from './basics/types';
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
 import EntityProperty from './EntityProperty__';
 import Entity from './Entity__';
-import { getNodeByNodeCallee } from '@nasl/automate/engine/utils';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -227,10 +227,55 @@ export class StructureProperty extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+
+    get hasChildren() {
+        const { typeKind, typeNamespace } = this.typeAnnotation;
+        if (typeKind === 'reference' || typeKind === 'generic') {
+            if (typeNamespace.endsWith('.enums'))
+                return null;
+            return [{}];
+        }
+        return null;
+    }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     /**
-     * 自动补全的字段列表
+     * 是否展开
      */
-    completionChildren: Array<EntityProperty | StructureProperty> = undefined;
+    @property()
+    isLeaf: boolean = true;
+
+    getSelectRef() {
+        try {
+            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                } else if (typeNamespace.endsWith('.enums')) {
+                    completionChildren = undefined;
+                } else {
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else if (typeKind === 'generic') {
+                // if (typeNamespace === 'nasl.collection' || typeNamespace === 'nasl.ui' || typeNamespace === 'nasl.interface') {
+                // }
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                completionChildren = properties;
+            } else {
+                completionChildren = undefined;
+            }
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
+        }
+    }
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
@@ -262,7 +307,7 @@ export class StructureProperty extends BaseNode {
                 // eslint-disable-next-line prefer-rest-params
                 throw new Error('找不到类型：' + arguments[0]);
         } else {
-            typeAnnotation._delete();
+            typeAnnotation._delete?.();
             const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
             Object.assign(typeAnnotation, relationOptions);
         }
@@ -291,20 +336,7 @@ export class StructureProperty extends BaseNode {
      * 是否可编辑
      * */
     get readonly() {
-        return !!this.module;
-    }
-
-    getSelectRef() {
-        const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-        let completionChildren;
-        if (typeKind === 'reference') {
-            const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
-            const properties = node.properties || [];
-            completionChildren = properties;
-        } else {
-            completionChildren = undefined;
-        }
-        return completionChildren;
+        return !!this.module || (this.parentNode as Structure).origin === 'CallQueryComponent';
     }
 
     //================================================================================

package/src/concepts/Structure__.ts

@@ -39,6 +39,12 @@ export class Structure extends BaseNode {
     @property()
     description: string = undefined;
 
+    /**
+     * 数据结构来源
+     */
+    @property()
+    origin: 'CallQueryComponent' = undefined;
+
     /**
      * 编译器信息
      */
@@ -124,7 +130,7 @@ export class Structure extends BaseNode {
         return (this.typeParams || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getTypeParamUniqueName(name = 'typeParam1') {
-        return utils.unique(name, this.getTypeParamExistingNames());
+        return utils.unique(name, this.getTypeParamExistingNames(), undefined, false);
     }
 
     /**
@@ -163,7 +169,7 @@ export class Structure extends BaseNode {
                 name: options,
             }, this, 'typeParams');
         } else if (options instanceof TypeParam) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             typeParam = options;
             Object.assign(typeParam, relationOptions);
         } else {
@@ -251,7 +257,7 @@ export class Structure extends BaseNode {
 
     addTypeParam(options?: string | Partial<TypeParam> | TypeParam) {
         const node = this._addTypeParam(options as any);
-        const index = this.typeParams.length;
+        const index = this.typeParams.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -266,7 +272,7 @@ export class Structure extends BaseNode {
         return (this.properties || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getPropertyUniqueName(name = 'property1') {
-        return utils.unique(name, this.getPropertyExistingNames());
+        return utils.unique(name, this.getPropertyExistingNames(), undefined, false);
     }
 
     /**
@@ -305,7 +311,7 @@ export class Structure extends BaseNode {
                 name: options,
             }, this, 'properties');
         } else if (options instanceof StructureProperty) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             property = options;
             Object.assign(property, relationOptions);
         } else {
@@ -393,7 +399,7 @@ export class Structure extends BaseNode {
 
     addProperty(options?: string | Partial<StructureProperty> | StructureProperty) {
         const node = this._addProperty(options as any);
-        const index = this.properties.length;
+        const index = this.properties.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -512,7 +518,7 @@ export class Structure extends BaseNode {
      * 是否可编辑
      * */
     get readonly() {
-        return !!this.module;
+        return !!this.module || this.origin === 'CallQueryComponent';
     }
     /* 删除空数据模块 */
     deleteLogincAndModule() {
@@ -526,7 +532,7 @@ export class Structure extends BaseNode {
     toEmbeddedTS(state?: TranslatorState): string {
         let code = `export class ${this.tsName} {\n`;
         code += indent(state.tabSize + 1);
-        code += `__name: '${this.getNamespace()}.${this.tsName}';\n`;
+        code += `__name: '${this.getTsNamespace()}.${this.tsName}';\n`;
         this.properties.forEach((property) => {
             code += indent(state.tabSize + 1);
             code += property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
@@ -544,6 +550,18 @@ export class Structure extends BaseNode {
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
 
+    getTsNamespace() {
+        if (this.parentNode.concept === 'App') {
+            return `${(this.parentNode as Namespace).getNamespace()}.structures`;
+        } else {
+            if (this.parentNode && (this.parentNode as Namespace).getTsNamespace) {
+                return `${(this.parentNode as Namespace).getTsNamespace()}.structures`;
+            } else {
+                throw new Error('无法获取命名空间，请设置 parentNode！');
+            }
+        }
+    }
+
     /**
      * 生成宿主语言的文件路径
      * @param name 一般不用传，用于 rename
@@ -554,10 +572,14 @@ export class Structure extends BaseNode {
     }
 
     toEmbeddedTSFile() {
-        let code = `namespace ${this.getNamespace()} {\n`;
+        let code = `namespace ${this.getTsNamespace()} {\n`;
 
         const state = createCompilerState(code, { tabSize: 1 });
-        code += this.toEmbeddedTS(state);
+        try {
+            code += this.toEmbeddedTS(state);
+        } catch (err) {
+            code += '';
+        }
         code += '}\n';
 
         return {

package/src/concepts/SwitchCase__.ts

@@ -89,7 +89,7 @@ export class SwitchCase extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'consequent' };
         let logicItem: LogicItem;
         if (options instanceof LogicItem) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logicItem = options;
             Object.assign(logicItem, relationOptions);
         } else {
@@ -163,7 +163,7 @@ export class SwitchCase extends LogicItem {
 
     addItem(options?: Partial<LogicItem> | LogicItem) {
         const node = this._addItem(options as any);
-        const index = this.consequent.length;
+        const index = this.consequent.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -249,7 +249,7 @@ export class SwitchCase extends LogicItem {
                 tabSize: 0,
             })) : '';
 
-            code += ')) {\n';
+            code += ') {\n';
 
             if (Array.isArray(this.consequent)) {
                 this.consequent.forEach((logicItem) => {
@@ -277,7 +277,7 @@ export class SwitchCase extends LogicItem {
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState, isLast?: boolean): string {
-        let code = '';
+        let code = '\n';
         if (!isLast) {
             code += 'if (nasl.core.ensureBoolean(';
             code += this.test ? this.test.toEmbeddedTS(shiftState(state, code, {

package/src/concepts/SwitchStatement__.ts

@@ -72,7 +72,7 @@ export class SwitchStatement extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'cases' };
         let switchCase: SwitchCase;
         if (options instanceof SwitchCase) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             switchCase = options;
             Object.assign(switchCase, relationOptions);
         } else {
@@ -146,7 +146,7 @@ export class SwitchStatement extends LogicItem {
 
     addSwitchCase(options?: Partial<SwitchCase> | SwitchCase) {
         const node = this._addSwitchCase(options as any);
-        const index = this.cases.length - 1;
+        const index = this.cases.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/TypeAnnotation__.ts

@@ -14,6 +14,20 @@ export enum PRIMITIVE_TYPE {
     Email = 'Email'
 }
 
+export const PRIMITIVE_TITLE: Record<string, string> = {
+    Boolean: '布尔值',
+    Integer: '整数',
+    Long: '长整数',
+    Double: '小数',
+    String: '字符串',
+    Text: '长文本',
+    Binary: '二进制流',
+    Date: '日期',
+    Time: '时间',
+    DateTime: '日期时间',
+    Email: '电子邮箱',
+};
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -62,13 +76,6 @@ export class TypeAnnotation extends BaseNode {
     @property('TypeAnnotation')
     typeArguments?: Array<TypeAnnotation> = null;
 
-    /**
-     * 显示文本
-     */
-    @excludedInJSON()
-    @property()
-    text?: string = undefined;
-
     /**
      * 是否是推断出来的
      */
@@ -116,7 +123,7 @@ export class TypeAnnotation extends BaseNode {
         const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
         let typeAnnotation: TypeAnnotation;
         if (options instanceof TypeAnnotation) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             typeAnnotation = options;
             Object.assign(typeAnnotation, relationOptions);
         } else {
@@ -190,7 +197,7 @@ export class TypeAnnotation extends BaseNode {
 
     addTypeAnnotation(options?: Partial<TypeAnnotation> | TypeAnnotation) {
         const node = this._addTypeAnnotation(options as any);
-        const index = this.typeArguments.length;
+        const index = this.typeArguments.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -252,13 +259,26 @@ export class TypeAnnotation extends BaseNode {
     }
 
     /**
-     * 临时展示 type 标题
+     * 用于展示的 type 标题
      */
     get typeTitle(): string {
-        if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
+        if (this.typeKind === 'primitive') {
+            return `${this.typeName} ${PRIMITIVE_TITLE[this.typeName]}`;
+        } else if (this.typeKind === 'reference') {
             return `${this.typeName}`;
         } else if (this.typeKind === 'generic') {
-            return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.typeTitle)}>`;
+            let str = `${this.typeName}`;
+            const loop = (typeArguments: Array<TypeAnnotation>) => {
+                str += '<' + (typeArguments[0].typeName || 'T');
+                if (typeArguments[0].typeKind === 'generic') {
+                    if (this.typeArguments && this.typeArguments.length) {
+                        loop(typeArguments[0].typeArguments);
+                    }
+                }
+                str += '>';
+            };
+            loop(this.typeArguments);
+            return str;
         } else {
             return this.typeName;
         }
@@ -319,19 +339,50 @@ export class TypeAnnotation extends BaseNode {
         return '';
     }
 
+    toJS(state?: TranslatorState): string {
+        return JSON.stringify(this);
+    }
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
-            if (this.typeKind === 'reference' && this.typeNamespace.endsWith('enums')) {
+            if (this.typeKind === 'reference' && this.typeNamespace && this.typeNamespace.endsWith('enums')) {
                 return `${this.tsCalleeNamespace}.${this.typeName}`;
             }
             return `${this.tsCalleeNamespace}.${this.typeName}`;
         } else if (this.typeKind === 'generic') {
             let code = `${this.tsCalleeNamespace}.${this.typeName}<`;
-            return code += `${(this.typeArguments || []).map((arg) => arg.toEmbeddedTS(shiftState(state, code, { inline: true })))}>`;
+            return (code += `${(this.typeArguments || []).map((arg) => arg.toEmbeddedTS(shiftState(state, code, { inline: true })))}>`);
         } else {
-            return this.typeName;
+            if (this.tsCalleeNamespace && this.typeName) {
+                return `${this.tsCalleeNamespace}.${this.typeName}`;
+            } else if (this.typeName) {
+                return this.typeName;
+            } else {
+                return '__IDENTIFIER__';
+            }
+        }
+    }
+
+    getDefaultValue(value: string) {
+        let code = '';
+        if (this.typeKind === 'primitive') {
+            if (this.typeName === 'String') {
+                code = `   "${value}" `;
+            } else {
+                if (['Long', 'Text'].includes(this.typeName)) {
+                    code = `  new ${this.typeNamespace}.${this.typeName}("${value}")`;
+                } else if (['Boolean'].includes(this.typeName)) {
+                    code = value;
+                } else {
+                    code = ` new ${this.typeNamespace}.${this.typeName}(${value})`;
+                }
+            }
+        } else {
+            code = ` ${this.typeNamespace}.${this.typeName}['${value}']`;
         }
+
+        return code;
     }
 
     /**

package/src/concepts/UnaryExpression__.ts

@@ -127,25 +127,25 @@ export class UnaryExpression extends LogicItem {
 
     toVue(options?: ElementToVueOptions) {
         if (this.operator === 'isNull') {
-            return this.argument.toVue(options);
+            return this.argument?.toVue(options);
         } else {
-            return '!' + this.argument.toVue(options);
+            return '!(' + this.argument?.toVue(options) + ')';
         }
     }
 
     toUI(state?: TranslatorState): string {
         if (this.operator === 'isNull') {
-            return this.argument.toUI(state);
+            return this.argument?.toUI(state);
         } else {
-            return '!' + this.argument.toUI(state);
+            return '!(' + this.argument?.toUI(state) + ')';
         }
     }
 
     toJS(state?: TranslatorState): string {
         if (this.operator === 'isNull') {
-            return this.argument.toJS(state);
+            return this.argument?.toJS(state);
         } else {
-            return '!' + this.argument.toJS(state);
+            return '!(' + this.argument?.toJS(state) + ')';
         }
     }
 
@@ -162,9 +162,11 @@ export class UnaryExpression extends LogicItem {
 
         let code = '';
         if (this.argument) {
-            code += `${this.operator}${this.argument}`;
+            code += `${this.operator}(`;
+            code += `${this.argument.toEmbeddedTS(shiftState(state, code))}`;
+            code += `)`;
         } else {
-            code += `${this.operator}__IDENTIFIER__`;
+            code += `${this.operator}(__IDENTIFIER__)`;
         }
         return code;
     }

package/src/concepts/Unparsed__.ts

@@ -81,7 +81,7 @@ export class Unparsed extends LogicItem {
 
     @withSourceMap()
     toEmbeddedTS(): string {
-        return this.code ? ` ${this.code} ` : '__IDENTIFIER__';
+        return 'nasl.core.universalVariable';
     }
 
     //================================================================================

package/src/concepts/ValidationRule__.ts

@@ -1,7 +1,7 @@
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
 import Function from './Function__';
 import { ElementToVueOptions } from './ViewElement__';
-
+import { getValidationInFunction } from '../server/getFunctions';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -92,7 +92,7 @@ export class ValidationRule extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'arguments' };
         let argument: Argument;
         if (options instanceof Argument) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             argument = options;
             Object.assign(argument, relationOptions);
         } else {
@@ -166,7 +166,7 @@ export class ValidationRule extends LogicItem {
 
     addArgument(options?: Partial<Argument> | Argument) {
         const node = this._addArgument(options as any);
-        const index = this.arguments.length;
+        const index = this.arguments.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -220,9 +220,9 @@ export class ValidationRule extends LogicItem {
         let code = this.calleeName;
         if (this.arguments.length) {
             code += '(';
-            this.arguments.forEach((arg, index) => {
-                code += arg.toVue(options);
-                if (index !== this.arguments.length - 1)
+            this.arguments?.forEach((arg, index) => {
+                code += arg?.toVue(options);
+                if (index !== this.arguments?.length - 1)
                     code += ', ';
             });
             code += ')';
@@ -232,11 +232,11 @@ export class ValidationRule extends LogicItem {
 
     toUI(state?: TranslatorState): string {
         let code = this.calleeName;
-        if (this.arguments.length) {
+        if (this.arguments?.length) {
             code += '(';
-            this.arguments.forEach((arg, index) => {
-                code += arg.toUI(shiftState(state, code));
-                if (index !== this.arguments.length - 1)
+            this.arguments?.forEach((arg, index) => {
+                code += arg?.toUI(shiftState(state, code));
+                if (index !== this.arguments?.length - 1)
                     code += ', ';
             });
             code += ')';
@@ -246,11 +246,11 @@ export class ValidationRule extends LogicItem {
 
     toJS(state?: TranslatorState): string {
         let code = this.calleeName;
-        if (this.arguments.length) {
+        if (this.arguments?.length) {
             code += '(';
-            this.arguments.forEach((arg, index) => {
-                code += arg.toJS(shiftState(state, code));
-                if (index !== this.arguments.length - 1)
+            this.arguments?.forEach((arg, index) => {
+                code += arg?.toJS(shiftState(state, code));
+                if (index !== this.arguments?.length - 1)
                     code += ', ';
             });
             code += ')';
@@ -258,6 +258,36 @@ export class ValidationRule extends LogicItem {
         return code;
     }
 
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState): string {
+        let code = '';
+        if (this.calleeName) {
+            if (this.arguments.length) {
+                const validationInFunction = getValidationInFunction(this.calleeName);
+                code += this.calleeKey;
+                code += '(';
+                this.arguments.forEach((arg, index) => {
+                    // 如果找到函数而且有参数，就用参数的必填非必填
+                    if (validationInFunction && validationInFunction.params[index]) {
+                        code += arg.toEmbeddedTS(shiftState(state, code), validationInFunction.params[index].required, false);
+                    } else {
+                        // 如果没有就默认不必填
+                        code += arg.toEmbeddedTS(shiftState(state, code), false, false);
+                    }
+                    if (index !== this.arguments.length - 1)
+                        code += ', ';
+                });
+                code += ')';
+            } else {
+                // 没有入参数的不需要校验
+                return 'null';
+            }
+        } else {
+            code += '__IDENTIFIER__';
+        }
+        return code;
+    }
+
     get calleeKey(): string {
         return `${this.calleeNamespace}.${this.calleeName}`;
     }