@lcap/nasl 3.3.2-beta.4 → 3.3.3-beta.2

package/sandbox/stdlib/nasl.core.ts

@@ -2,189 +2,191 @@ type BooleanAlias = Boolean;
 type StringAlias = String;
 
 declare namespace nasl.core {
-    export type Any = any;
-    export class Boolean extends globalThis.Boolean {
-    }
-    // Long<Long<Decimal<Decimal  小类型可以隐式转换为大类型，反之不可。
-    // export class Long {
-    //     accept: 'Long';
-    //     constructor(num?: number);
-    // }
-
-    // export class Decimal {
-    //     accept: 'Decimal' | 'Long' | 'Long';
-    //     constructor(num?: number);
-    // }
-    export class Decimal {
-        accept: 'Decimal' | 'Long';
-        constructor(num?: number);
-    }
-
-    export class Long {
-        accept: 'Long' ;
-        constructor(num?: number);
-    }
-
-    export class String extends globalThis.String {
-        // @ts-ignore
-        length: nasl.core.Long;
-    }
-
-    export class Text extends String {
-    }
-
-    export class Binary {
-        accept: 'Binary';
-    }
-
-    export class Date {
-        accept: 'Date';
-    }
-
-    export class Time {
-        accept: 'Time';
-    }
-
-    export class DateTime {
-        accept: 'DateTime';
-    }
-
-    // export class Email extends String {
-    //     subAccept: 'Email';
-    // }
-
-    export class Union {
-        accept: 'Union';
-    }
-
-    // &&
-    export function and(left: Boolean, right: Boolean): Boolean;
-    // ||
-    export function or(left: Boolean, right: Boolean): Boolean;
-
-    export function add(left: Long, right: Long): Long;
-    export function add(left: Decimal, right: Decimal): Decimal;
-    export function add(left: String, right: Any): String;
-    export function add(left: Any, right: String): String;
-    export function add(left: Long, right: Long): Long; // 为了让提示到整数上，最后补一个重载
-
-    export function minus(left: Long, right: Long): Long;
-    export function minus(left: Decimal, right: Decimal): Decimal;
-    export function minus(left: Long, right: Long): Long;
-
-    export function multiply(left: Long, right: Long): Long;
-    export function multiply(left: Decimal, right: Decimal): Decimal;
-    export function multiply(left: Long, right: Long): Long;
-
-    export function divide(left: Long, right: Long): Decimal;
-    export function divide(left: Decimal, right: Decimal): Decimal;
-    export function divide(left: Long, right: Long): Decimal;
-
-    export function remainder(left: Long, right: Long): Long;
-    export function remainder(left: Decimal, right: Decimal): Decimal;
-    export function remainder(left: Long, right: Long): Long;
-
-    export function equal<T>(left: T, right: T): Boolean;
-    export function notEqual<T>(left: T, right: T): Boolean;
-
-    export function greaterThan(left: Long, right: Long): Boolean;
-    export function greaterThan(left: String, right: String): Boolean;
-    export function greaterThan(left: Date, right: Date): Boolean;
-    export function greaterThan(left: Time, right: Time): Boolean;
-    export function greaterThan(left: DateTime, right: DateTime): Boolean;
-    export function greaterThan(left: Decimal, right: Decimal): Boolean;
-    export function greaterThan(left: Long, right: Long): Boolean;
-
-    export function lessThan(left: Long, right: Long): Boolean;
-    export function lessThan(left: String, right: String): Boolean;
-    export function lessThan(left: Date, right: Date): Boolean;
-    export function lessThan(left: Time, right: Time): Boolean;
-    export function lessThan(left: DateTime, right: DateTime): Boolean;
-    export function lessThan(left: Decimal, right: Decimal): Boolean;
-    export function lessThan(left: Long, right: Long): Boolean;
-
-    export function greaterThanOrEqual(left: Long, right: Long): Boolean;
-    export function greaterThanOrEqual(left: String, right: String): Boolean;
-    export function greaterThanOrEqual(left: Date, right: Date): Boolean;
-    export function greaterThanOrEqual(left: Time, right: Time): Boolean;
-    export function greaterThanOrEqual(left: DateTime, right: DateTime): Boolean;
-    export function greaterThanOrEqual(left: Decimal, right: Decimal): Boolean;
-    export function greaterThanOrEqual(left: Long, right: Long): Boolean;
-
-    export function lessThanOrEqual(left: Long, right: Long): Boolean;
-    export function lessThanOrEqual(left: String, right: String): Boolean;
-    export function lessThanOrEqual(left: Date, right: Date): Boolean;
-    export function lessThanOrEqual(left: Time, right: Time): Boolean;
-    export function lessThanOrEqual(left: DateTime, right: DateTime): Boolean;
-    export function lessThanOrEqual(left: Decimal, right: Decimal): Boolean;
-    export function lessThanOrEqual(left: Long, right: Long): Boolean;
-
-    export function ensureBoolean(value: Boolean): Boolean;
-    export function ensureVoid<T>(value: IsVoid<T>): Boolean
-
-    export function isUnionType<T, S extends T>(obj: T): obj is S;
-
-    // 代替原来的赋值语句，就只校验左右类型是不是可以赋值，但是不会改变原始类型
-    export function assign<T1, T2 extends T1>(left: T1, right: T2): T1;
-    export let universalVariable: nasl.core.Any;
-
-    // new 组件对比类型
-    export function compareNew(left: Date, right: Date): Boolean;
-    export function compareNew(left: Time, right: Time): Boolean;
-    export function compareNew(left: DateTime, right: DateTime): Boolean;
-    export function compareNew(left: Long, right: Long): Boolean;
-    export function compareNew(left: Long, right: Decimal): Boolean;
-    export function compareNew(left: Decimal, right: Long): Boolean;
-    export function compareNew(left: String, right: String): Boolean;
-    export function compareNew(left: Decimal, right: Decimal): Boolean;
-    export function compareNew<T>(left: T, right: T): Boolean;
-
-    // OQL 临时补救
-    export function compare2(left: Date, right: String): Boolean;
-    export function compare2(left: DateTime, right: String): Boolean;
-    export function compare2(left: String, right: Date): Boolean;
-    export function compare2(left: String, right: DateTime): Boolean;
-    export function compare2(left: String, right: Time): Boolean;
-    export function compare2(left: Date, right: Date): Boolean;
-    export function compare2(left: Time, right: Time): Boolean;
-    export function compare2(left: DateTime, right: DateTime): Boolean;
-    export function compare2(left: String, right: String): Boolean;
-    export function compare2(left: Long, right: Long): Boolean;
-    export function compare2(left: Long, right: Decimal): Boolean;
-    export function compare2(left: Decimal, right: Long): Boolean;
-    export function compare2(left: Decimal, right: Decimal): Boolean;
-    export function compare2<T>(left: T, right: T): Boolean;
-
-    // 包括 +
-    export function add2(left: Long, right: Long): Long;
-    export function add2(left: Decimal, right: Decimal): Decimal;
-    export function add2(left: Long, right: Long): Long;
-    export function add2(left: Long, right: Decimal): Decimal;
-    export function add2(left: Decimal, right: Long): Decimal;
-    export function add2(left: String, right: Any): String;
-    export function add2(left: Any, right: String): String;
-    export function add2(left: Long, right: Long): Long; // 为了让提示到整数上，最后补一个重载
-
-    // 包括 - * %
-    export function arith2(left: Long, right: Long): Long;
-    export function arith2(left: Decimal, right: Decimal): Decimal;
-    export function arith2(left: Long, right: Decimal): Decimal;
-    export function arith2(left: Decimal, right: Long): Decimal;
-    export function arith2(left: Long, right: Long): Long; // 为了让提示到整数上，最后补一个重载
-
-    // 包括 /
-    export function divided2(left: Long, right: Long): Decimal;
-    export function divided2(left: Decimal, right: Decimal): Decimal;
-    export function divided2(left: Long, right: Decimal): Decimal;
-    export function divided2(left: Decimal, right: Long): Decimal;
-    export function divided2(left: Long, right: Long): Decimal; // 为了让提示到整数上，最后补一个重载
-
-    export class Enums {
-        accept: 'Enums';
-    }
-    export class None {
-        accept: 'None';
-    }
-    export type Incompatible<A, B> = A extends B ? never : A
-    export type IsVoid<T> = T extends void ? never : T
+  export type Any = any;
+  export class Boolean extends globalThis.Boolean {
+  }
+  // Long<Long<Decimal<Decimal  小类型可以隐式转换为大类型，反之不可。
+  // export class Long {
+  //     accept: 'Long';
+  //     constructor(num?: number);
+  // }
+
+  // export class Decimal {
+  //     accept: 'Decimal' | 'Long' | 'Long';
+  //     constructor(num?: number);
+  // }
+  export class Decimal {
+    accept: 'Decimal' | 'Long';
+    constructor(num?: number);
+  }
+
+  export class Long {
+    accept: 'Long';
+    constructor(num?: number);
+  }
+
+  export class String extends globalThis.String {
+    // @ts-ignore
+    length: nasl.core.Long;
+  }
+
+  export class Text extends String {
+  }
+
+  export class Binary {
+    accept: 'Binary';
+  }
+
+  export class Date {
+    accept: 'Date';
+  }
+
+  export class Time {
+    accept: 'Time';
+  }
+
+  export class DateTime {
+    accept: 'DateTime';
+  }
+
+  // export class Email extends String {
+  //     subAccept: 'Email';
+  // }
+
+  export class Union {
+    accept: 'Union';
+  }
+
+  // &&
+  export function and(left: Boolean, right: Boolean): Boolean;
+  // ||
+  export function or(left: Boolean, right: Boolean): Boolean;
+
+  export function add(left: Long, right: Long): Long;
+  export function add(left: Decimal, right: Decimal): Decimal;
+  export function add(left: String, right: Any): String;
+  export function add(left: Any, right: String): String;
+  export function add(left: Long, right: Long): Long; // 为了让提示到整数上，最后补一个重载
+
+  export function minus(left: Long, right: Long): Long;
+  export function minus(left: Decimal, right: Decimal): Decimal;
+  export function minus(left: Long, right: Long): Long;
+
+  export function multiply(left: Long, right: Long): Long;
+  export function multiply(left: Decimal, right: Decimal): Decimal;
+  export function multiply(left: Long, right: Long): Long;
+
+  export function divide(left: Long, right: Long): Decimal;
+  export function divide(left: Decimal, right: Decimal): Decimal;
+  export function divide(left: Long, right: Long): Decimal;
+
+  export function remainder(left: Long, right: Long): Long;
+  export function remainder(left: Decimal, right: Decimal): Decimal;
+  export function remainder(left: Long, right: Long): Long;
+
+  export function equal<T>(left: T, right: T): Boolean;
+  export function isEqual<T>(left: T, right: T): Boolean;
+  export function notEqual<T>(left: T, right: T): Boolean;
+  export function isNotEqual<T>(left: T, right: T): Boolean;
+
+  export function greaterThan(left: Long, right: Long): Boolean;
+  export function greaterThan(left: String, right: String): Boolean;
+  export function greaterThan(left: Date, right: Date): Boolean;
+  export function greaterThan(left: Time, right: Time): Boolean;
+  export function greaterThan(left: DateTime, right: DateTime): Boolean;
+  export function greaterThan(left: Decimal, right: Decimal): Boolean;
+  export function greaterThan(left: Long, right: Long): Boolean;
+
+  export function lessThan(left: Long, right: Long): Boolean;
+  export function lessThan(left: String, right: String): Boolean;
+  export function lessThan(left: Date, right: Date): Boolean;
+  export function lessThan(left: Time, right: Time): Boolean;
+  export function lessThan(left: DateTime, right: DateTime): Boolean;
+  export function lessThan(left: Decimal, right: Decimal): Boolean;
+  export function lessThan(left: Long, right: Long): Boolean;
+
+  export function greaterThanOrEqual(left: Long, right: Long): Boolean;
+  export function greaterThanOrEqual(left: String, right: String): Boolean;
+  export function greaterThanOrEqual(left: Date, right: Date): Boolean;
+  export function greaterThanOrEqual(left: Time, right: Time): Boolean;
+  export function greaterThanOrEqual(left: DateTime, right: DateTime): Boolean;
+  export function greaterThanOrEqual(left: Decimal, right: Decimal): Boolean;
+  export function greaterThanOrEqual(left: Long, right: Long): Boolean;
+
+  export function lessThanOrEqual(left: Long, right: Long): Boolean;
+  export function lessThanOrEqual(left: String, right: String): Boolean;
+  export function lessThanOrEqual(left: Date, right: Date): Boolean;
+  export function lessThanOrEqual(left: Time, right: Time): Boolean;
+  export function lessThanOrEqual(left: DateTime, right: DateTime): Boolean;
+  export function lessThanOrEqual(left: Decimal, right: Decimal): Boolean;
+  export function lessThanOrEqual(left: Long, right: Long): Boolean;
+
+  export function ensureBoolean(value: Boolean): Boolean;
+  export function ensureVoid<T>(value: IsVoid<T>): Boolean
+
+  export function isUnionType<T, S extends T>(obj: T): obj is S;
+
+  // 代替原来的赋值语句，就只校验左右类型是不是可以赋值，但是不会改变原始类型
+  export function assign<T1, T2 extends T1>(left: T1, right: T2): T1;
+  export let universalVariable: nasl.core.Any;
+
+  // new 组件对比类型
+  export function compareNew(left: Date, right: Date): Boolean;
+  export function compareNew(left: Time, right: Time): Boolean;
+  export function compareNew(left: DateTime, right: DateTime): Boolean;
+  export function compareNew(left: Long, right: Long): Boolean;
+  export function compareNew(left: Long, right: Decimal): Boolean;
+  export function compareNew(left: Decimal, right: Long): Boolean;
+  export function compareNew(left: String, right: String): Boolean;
+  export function compareNew(left: Decimal, right: Decimal): Boolean;
+  export function compareNew<T>(left: T, right: T): Boolean;
+
+  // OQL 临时补救
+  export function compare2(left: Date, right: String): Boolean;
+  export function compare2(left: DateTime, right: String): Boolean;
+  export function compare2(left: String, right: Date): Boolean;
+  export function compare2(left: String, right: DateTime): Boolean;
+  export function compare2(left: String, right: Time): Boolean;
+  export function compare2(left: Date, right: Date): Boolean;
+  export function compare2(left: Time, right: Time): Boolean;
+  export function compare2(left: DateTime, right: DateTime): Boolean;
+  export function compare2(left: String, right: String): Boolean;
+  export function compare2(left: Long, right: Long): Boolean;
+  export function compare2(left: Long, right: Decimal): Boolean;
+  export function compare2(left: Decimal, right: Long): Boolean;
+  export function compare2(left: Decimal, right: Decimal): Boolean;
+  export function compare2<T>(left: T, right: T): Boolean;
+
+  // 包括 +
+  export function add2(left: Long, right: Long): Long;
+  export function add2(left: Decimal, right: Decimal): Decimal;
+  export function add2(left: Long, right: Long): Long;
+  export function add2(left: Long, right: Decimal): Decimal;
+  export function add2(left: Decimal, right: Long): Decimal;
+  export function add2(left: String, right: Any): String;
+  export function add2(left: Any, right: String): String;
+  export function add2(left: Long, right: Long): Long; // 为了让提示到整数上，最后补一个重载
+
+  // 包括 - * %
+  export function arith2(left: Long, right: Long): Long;
+  export function arith2(left: Decimal, right: Decimal): Decimal;
+  export function arith2(left: Long, right: Decimal): Decimal;
+  export function arith2(left: Decimal, right: Long): Decimal;
+  export function arith2(left: Long, right: Long): Long; // 为了让提示到整数上，最后补一个重载
+
+  // 包括 /
+  export function divided2(left: Long, right: Long): Decimal;
+  export function divided2(left: Decimal, right: Decimal): Decimal;
+  export function divided2(left: Long, right: Decimal): Decimal;
+  export function divided2(left: Decimal, right: Long): Decimal;
+  export function divided2(left: Long, right: Long): Decimal; // 为了让提示到整数上，最后补一个重载
+
+  export class Enums {
+    accept: 'Enums';
+  }
+  export class None {
+    accept: 'None';
+  }
+  export type Incompatible<A, B> = A extends B ? never : A
+  export type IsVoid<T> = T extends void ? never : T
 }

package/src/bak/translator.js

@@ -9,12 +9,12 @@ function tryJSONParse(str) {
 
   try {
     result = JSON.parse(str);
-  } catch (e) {}
+  } catch (e) { }
 
   return result;
 }
 
-export default function (definition) {
+export default function (definition, view) {
   /**
    * 页面的 data
    * 包含 页面变量 / 页面入参 / 页面元素绑定的表达式的返回
@@ -33,21 +33,44 @@ export default function (definition) {
   viewVariables.forEach((viewVariable) => {
     dataMap[viewVariable.code || viewVariable.name] = true;
     const typeAnnotation = viewVariable.typeAnnotation || viewVariable.__TypeAnnotation;
+    let { typeKind, typeNamespace, typeName, sortedTypeKey } = typeAnnotation || {};
+    if (typeNamespace?.endsWith('.metadataTypes')) {
+      const referenceNode = view.getAncestor('App').findNodeByCompleteName(typeNamespace + '.' + typeName) || {}
+      const typeAn = referenceNode.typeAnnotation || {};
+      typeKind = typeAn.typeKind;
+      typeNamespace = typeAn.typeNamespace;
+      typeName = typeAn.typeName;
+      sortedTypeKey = `${typeNamespace}.${typeName}`;
+      if (`${viewVariable.defaultValue}` === 'undefined' || `${viewVariable.defaultValue}` === 'null') {
+        viewVariable?.setDefaultValue('')
+      }
+    }
     const needGenInitFromSchema =
-      typeAnnotation && (!['primitive', 'union'].includes(typeAnnotation.typeKind) || typeAnnotation.typeName === 'DateTime');
+      typeAnnotation && (!['primitive', 'union'].includes(typeKind) || typeName === 'DateTime');
     let code = `${safeCodeAsKey(viewVariable.name)}:`;
     if (needGenInitFromSchema) {
-      code += `this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', `;
+      code += `this.$genInitFromSchema('${sortedTypeKey}', `;
     }
     if (viewVariable.concept === 'Param') {
-      code += `this.$route.query.hasOwnProperty('${viewVariable.name}') ? this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', this.$route.query.${viewVariable.name}) :`;
+      code += `this.$route.query.hasOwnProperty('${viewVariable.name}') ? this.$genInitFromSchema('${sortedTypeKey}', this.$route.query.${viewVariable.name}) :`;
     }
 
     const { defaultValue } = viewVariable;
     const defaultValueType = Object.prototype.toString.call(defaultValue);
-    const { typeKind, typeNamespace, typeName } = typeAnnotation || {};
     // 设置成null，才能同步给后端清除该值，但是null对checkbox组件是一种特殊状态
     let parsedValue = defaultValue ?? undefined;
+    const isDecimal = typeKind === 'primitive' && ['Decimal', "Double"].includes(typeName)
+    const isInteger = typeKind === 'primitive' && ['Long', "Integer"].includes(typeName)
+    function parseNumberValue(defaultValue, typeAnnotation) {
+      const { typeKind, typeName } = typeAnnotation;
+      const isNaslNumber = typeKind === 'primitive' && ['Decimal', 'Long', 'Double', 'Int'].includes(typeName);
+      if (isNaslNumber) {
+        return String(defaultValue);
+      } else {
+        return tryJSONParse(defaultValue) ?? defaultValue;
+      }
+    }
+
     if (
       defaultValueType === '[object String]' &&
       !(typeKind === 'primitive' && typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) &&
@@ -59,10 +82,20 @@ export default function (definition) {
       if ([''].includes(defaultValue)) {
         parsedValue = undefined;
       } else {
-        parsedValue = tryJSONParse(defaultValue) ?? defaultValue;
+        parsedValue = parseNumberValue(defaultValue, typeAnnotation);
       }
     }
-    code += `${JSON.stringify(parsedValue)}`;
+    // code += `${JSON.stringify(parsedValue)}`;
+    const isNil = val => val === undefined || val === null;
+    if (isDecimal) {
+      parsedValue = isNil(parsedValue) ? parsedValue : `new NaslDecimal('${parsedValue}')`
+      code += `${parsedValue} `;
+    } else if (isInteger) {
+      parsedValue = isNil(parsedValue) ? parsedValue : `new NaslLong('${parsedValue}')`
+      code += `${parsedValue} `;
+    } else {
+      code += `${JSON.stringify(parsedValue)} `;
+    }
     if (needGenInitFromSchema) {
       code += `)`;
     }
@@ -92,48 +125,48 @@ export default function (definition) {
     })
   })
   definition.elements.forEach(element => {
-      element.bindAttrs.filter((attr) => PAGE_COMPONENT_INCLUDE_TAG_MAP[element.tag]?.[attr.name]).forEach(attr => {
-        let variable = '';
-        if (attr.expression) {
-          variable += `${attr.expression.toJS()}`
-            // attrsData.push(code)
-        } else if (attr.type === 'static') {
-          variable = `${attr.value}`
-            // attrsData.push(code)
-        }
-        if (attr.expression?.concept === 'CallLogic' && attr.name === 'data-source') {
-          const codeLoad = `async '__${element.name}_dataSourceLoad'(params) {
+    element.bindAttrs.filter((attr) => PAGE_COMPONENT_INCLUDE_TAG_MAP[element.tag]?.[attr.name]).forEach(attr => {
+      let variable = '';
+      if (attr.expression) {
+        variable += `${attr.expression.toJS()}`
+        // attrsData.push(code)
+      } else if (attr.type === 'static') {
+        variable = `${attr.value}`
+        // attrsData.push(code)
+      }
+      if (attr.expression?.concept === 'CallLogic' && attr.name === 'data-source') {
+        const codeLoad = `async '__${element.name}_dataSourceLoad'(params) {
             this['__${element.name}_params'] = {...params};
             return ${variable}
           }`
-          viewMethodData.push(codeLoad)
-          const code = `async '__${element.name}_dataSource'(params) {
+        viewMethodData.push(codeLoad)
+        const code = `async '__${element.name}_dataSource'(params) {
             return ${variable}
           }`
-          viewMethodData.push(code)
-        } else {
-          const code = `'__${element.name}_${attrConvertCamelCase(attr.name)}'(${variable.includes('(current || {}).item') ? 'current' : ''}) {
+        viewMethodData.push(code)
+      } else {
+        const code = `'__${element.name}_${attrConvertCamelCase(attr.name)}'(${variable.includes('(current || {}).item') ? 'current' : ''}) {
               return ${variable?.trim()?.length > 0 ? variable : undefined}
           }`
-          viewMethodData.push(code)
-        }
-      })
-      viewVariablesData.push(`['__${element.name}_params']: {}`);
-      // if (['u-select', 'van-pickerson'].includes(element.tag)) {
-      //     viewMethodData.push(`['__${element.name}_page-number']() {
-      //         return this['__${element.name}_params']?.page ?? 1
-      //     }`)
-      //     viewMethodData.push(`['__${element.name}_filterText']() {
-      //         return this['__${element.name}_params']?.filterText ?? ''
-      //     }`)
-      // } else if (['u-list-view', 'u-grid-view', 'u-table-view', 'van-list-view', 'van-grid-view'].includes(element.tag) && element.bindAttrs?.findIndex((attr) => attr.name === 'sorting') === -1) {
-      //   viewMethodData.push(`['__${element.name}_sorting']() {
-      //         return {
-      //             field: undefined,
-      //             order: undefined
-      //         }
-      //     }`)
-      // }
+        viewMethodData.push(code)
+      }
+    })
+    viewVariablesData.push(`['__${element.name}_params']: {}`);
+    // if (['u-select', 'van-pickerson'].includes(element.tag)) {
+    //     viewMethodData.push(`['__${element.name}_page-number']() {
+    //         return this['__${element.name}_params']?.page ?? 1
+    //     }`)
+    //     viewMethodData.push(`['__${element.name}_filterText']() {
+    //         return this['__${element.name}_params']?.filterText ?? ''
+    //     }`)
+    // } else if (['u-list-view', 'u-grid-view', 'u-table-view', 'van-list-view', 'van-grid-view'].includes(element.tag) && element.bindAttrs?.findIndex((attr) => attr.name === 'sorting') === -1) {
+    //   viewMethodData.push(`['__${element.name}_sorting']() {
+    //         return {
+    //             field: undefined,
+    //             order: undefined
+    //         }
+    //     }`)
+    // }
   })
 
   let viewExpressionMethods;