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

package/sandbox-natural/stdlib/nasl.core.ts

@@ -0,0 +1,36 @@
+type Any = any;
+// type Boolean = boolean;
+type Integer = number;
+type Decimal = number;
+// type String = string;
+// type Date = globalThis.Date;
+class Time {
+    accept: 'Time';
+}
+class DateTime {
+    accept: 'DateTime';
+}
+type List<T> = Array<T>;
+
+interface Entity<T> {
+    get(id: Long): T;
+    create(entity: T): T;
+    update(entity: T): T;
+    delete(id: Long): void;
+    createOrUpdate(body: T): T;
+    updateBy(body: T, filter: (_: T) => Boolean): Integer;
+    deleteBy(filter: (_: T) => Boolean): void;
+    batchCreate(list: List<T>): List<T>;
+    batchUpdate(list: List<T>): List<T>;
+    batchDelete(list: List<Long>): void;
+}
+declare function EntityRelation(property: any):any;
+declare const createEntity: <T>() => Entity<T>;
+
+declare function ForEach<T>(list: List<T>, start: Integer, end: Integer, fn: (item: T, index: Integer) => void): void;
+
+declare function plus(left: Decimal, right: Decimal): Decimal;
+declare function minus(left: Decimal, right: Decimal): Decimal;
+declare function multiply(left: Decimal, right: Decimal): Decimal;
+declare function divide(left: Decimal, right: Decimal): Decimal;
+declare function remainder(left: Decimal, right: Decimal): Decimal;

package/sandbox-natural/stdlib/nasl.oql.ts

@@ -0,0 +1,8 @@
+declare namespace nasl.oql {
+    /**
+     * 数据查询
+     * @param sql 数据查询需要的 SQL
+     * @returns 返回类型中的 T 为 sql 根据 SQL 中 select 的字段推导
+     */
+    export function query<T>(sql: string): List<T>;
+}

package/sandbox-natural/stdlib/nasl.ui.ts

@@ -0,0 +1,63 @@
+declare namespace nasl.ui {
+    export interface MouseEvent {}
+
+    export interface ValidateEvent { valid: Boolean; }
+
+    export class Button {
+        constructor(options?: {
+            color?: 'default' | 'primary',
+            text?: String,
+            onClick?: () => any,
+        });
+    }
+
+    export class Form {
+        constructor(options?: {});
+
+        validate(): ValidateEvent;
+    }
+
+    export class Modal {
+        constructor(options?: {});
+
+        open(): void;
+        close(): void;
+    }
+
+    export class TableView {
+        constructor(options?: {});
+
+        reload(): void;
+    }
+
+    export class Select {
+        constructor(options?: {});
+
+        reload(): void;
+    }
+
+    export class InfoList {
+        constructor(options?: {});
+    }
+
+    export class Collapse {
+        constructor(options?: {});
+    }
+
+    export class Input {
+        constructor(options?: {});
+    }
+
+    export class NumberInput {
+        constructor(options?: {});
+    }
+
+    export function showMessage(text: Any): void;
+
+    /**
+     * 跳转页面
+     * @example nasl.ui.destination('some_view.sub1_view', param1, param2);
+     */
+    export function destination(path: String, ...args: Any[]): void;
+}
+

package/sandbox-natural/stdlib/nasl.util.ts

@@ -0,0 +1,119 @@
+declare namespace nasl.util {
+    // 类型转换与格式化函数
+    export function Convert(value: null): <T extends never>() => T;
+    export function FormatNumber(doubleValue: Decimal | Integer, digits: Integer, showGroups: Boolean): String;
+    export function FormatDateTime(dateTime: DateTime, formatter: String): String;
+    export function FormatDate(date: Date, formatter: String): String;
+    /**
+     * @example nasl.util.FromString<Date>(variable1)
+     */
+    export function FromString<T extends Decimal | Date | Time | DateTime | Integer | Boolean>(value: String): T;
+    export function ToString(value: Any): String;
+
+    // 字符串函数
+    export function Concat(...args: Any): String;
+    export function Length(str1: String): Decimal;
+    export function Length<K, V>(str1: Map<K, V>): Decimal;
+    export function Length<T>(str1: List<T>): Decimal;
+    export function IndexOf(str: String, search: String, formIndex: Decimal, ignoreCase: Boolean): Decimal;
+    export function Join(list: List<Any>, seperator: String): String;
+    export function LastIndexOf(str: String, search: String, ignoreCase: Boolean): Decimal;
+    export function Replace(str: String, search: String, replace: String): String;
+    export function Split(str: String, seperator: String): List<String>;
+    export function SubString(str: String, start: Decimal, length: Integer): String;
+    export function ToLower(str1: String): String;
+    export function ToUpper(str1: String): String;
+    export function Trim(str1: String): String;
+
+    // 日期与时间函数
+    export function CurrDate(): Date;
+    export function CurrDateTime(): DateTime;
+    export function CurrTime(): Time;
+    export function DateDiff<T extends Date | Time | DateTime>(dateTime1: T, dateTime2: T, calcType: 'd' | 'h' | 'm' | 's', isAbs: Boolean): Decimal;
+
+    // 列表（List）函数
+    export function Add<T, K extends T>(list: List<T>, item: K): void;
+    export function AddAll<T>(list: List<T>, addList: List<T>): Decimal;
+    export function Contains<T, K extends T>(list: List<T>, item: K): Boolean;
+    export function Insert<T, K extends T>(list: List<T>, index: Decimal, item: K): void;
+    export function ListDistinct<T>(list: List<T>): void;
+    export function ListDistinctBy<A>(list: List<A>, by: List<{ items: Array<(elem: A) => any> }>): List<A>;
+    export function ListFilter<T>(list: List<T>, by: (item: T) => Boolean): List<T>;
+    export function ListFind<T>(list: List<T>, by: (item: T) => Boolean): T;
+    export function ListFindIndex<T>(list: List<T>, by: (item: T) => Boolean): Decimal;
+    export function ListFlatten<T>(list: List<List<T>>): List<T>;
+    export function ListGroupBy<A, K extends Boolean | Decimal | Decimal | String>(list: List<A>, by: (elem: A) => K): Map<K, List<A>>;
+    export function ListHead<T>(list: List<T>): T;
+    export function ListLast<T>(list: List<T>): T;
+    export function ListMax<T extends Decimal | Decimal | String>(list: List<T>): T;
+    export function ListMin<T extends Decimal | Decimal | String>(list: List<T>): T;
+    export function ListReverse<T>(list: List<T>): void;
+    export function ListSlice<T>(list: List<T>, start: Decimal, end: Decimal): List<T>;
+    export function ListSort<T>(list: List<T>, by: (item: T) => any, sort: Boolean): void;
+    export function ListSum<T extends Integer | Decimal>(list: List<T>): T;
+    export function ListToMap<T, K extends Boolean | Decimal | Decimal | String, V>(map: List<T>, byKey: (elem: T) => K, byVal: (elem: T) => V): Map<K, V>;
+    export function ListTransform<T0, T>(list: List<T0>, by : (elem : T0) => T): List<T>;
+    export function Get<T>(list: List<T>, index: Decimal): T;
+    export function Remove<T, K extends T>(list: List<T>, item: K): void;
+    export function RemoveAt<T>(list: List<T>, index: Integer): T;
+    export function Set<T, K extends T>(list: List<T>, index: Decimal, item: K): T;
+
+    // 映射（Map）函数
+    export function MapContains<K, V>(map: Map<K, V>, key: K): Boolean;
+    export function MapGet<K, V>(map: Map<K, V>, key: K): V;
+    export function MapPut<K, V>(map: Map<K, V>, key: K, value: V): void;
+    export function MapKeys<K, V>(map: Map<K, V>): List<K>;
+    export function MapRemove<K, V>(map: Map<K, V>, key: K): void;
+    export function MapValues<K, V>(map: Map<K, V>): List<V>;
+
+    // 枚举函数
+    /**
+    * @example nasl.util.EnumToList<aEnum>({ typeNamespace: 'app.enums' });
+    */
+    export function EnumToList<T extends Enums>({ typeNamespace } : { typeNamespace: 'app.enums' }): void;
+    export function EnumValueToText<T extends Enums>(value: any, { typeNamespace } : { typeNamespace: 'app.enums' }): String;
+    export function StringToEnumValue<T extends Enums>(value: String, { typeNamespace } : { typeNamespace: 'app.enums' }): String;
+
+    // 数学函数
+    /**
+    * 整数/小数 操作
+    * @param mode: 'HalfUp' | 'TowardsZero' | 'TowardsInfinity' === '四舍五入' | '截断、向零取整，如 -2.6 取整为 -2' | '进位、向正负无穷取整，如 -1.1 取整为 -2'
+    */
+    export function Round(value: Decimal, mode: 'HalfUp' | 'TowardsZero' | 'TowardsInfinity'): Decimal;
+
+    // 其他函数
+    export function Clear<T>(struct: T): T;
+    export function Clone<T>(struct: T): T;
+    export function HasValue(...args: Any[]): Boolean;
+    export function RandomInt(start: Integer, end: Integer): Integer;
+
+    // New 系列函数使用
+    /**
+    * T 必填
+    * @example const variable1 = nasl.util.NewList<Boolean | Long>([true, false, 1])
+    */
+    export function NewList<T>(args: T[]): List<T>;
+    /**
+    * T 必填
+    * @example const variable1 = nasl.util.NewMap<String, Long>({'123': 456})
+    */
+    export function NewMap<K, T>(args: any): Map<K, T>;
+    /**
+    * T 必填
+    * class Entity1 { id: Long; property1: String; property2: String;}
+    * @example const variable1 = nasl.util.NewEntity<Entity1>({id: 123, property1: '123', property2: '456'})
+    */
+    export function NewEntity<T>(arg: T): T;
+    /**
+    * @example const variable1 = nasl.util.NewAnonymityStructure({property1: '123', property2: '456'})
+    */
+    export function NewAnonymityStructure(arg: any): any;
+
+    export function consoleLog(arg: Any): void;
+    export function jsonSerialize(arg: Any): String;
+    /**
+    * T 为返回值类型，必填
+    * @example nasl.util.jsonDeserialize<Boolean>(variable1);
+    */
+    export function jsonDeserialize<T>(arg: String): T;
+}

package/sandbox-natural/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+        "target": "ES2015",
+        "module": "ES2015",
+        "lib": ["ES2015"],
+        "skipLibCheck": true,
+        "disableSizeLimit": true,
+        "experimentalDecorators": true,
+        "noImplicitAny": true,
+        "rootDir": "."
+    }
+}

package/src/bak/translator.js

@@ -91,13 +91,10 @@ export default function (definition) {
               }`
               viewMethodData.push(code)
           } else {
-              const code = `'__${element.name}_${attr.name}'(${variable.includes('(current || {}).item') ? 'current' : ''}) {
-                  return ${variable?.trim()?.length > 0 ? variable : undefined}
+              const code = `['__${element.name}_${attr.name}']() {
+                  return ${variable}
               }`
-              if (element.name === 'table_view1') {
-                console.log('在这里', code, variable)
-              }
-              viewMethodData.push(code)
+              viewComputedData.push(code)
           }
       })
       if (['u-select', 'van-pickerson'].includes(element.tag)) {
@@ -105,9 +102,9 @@ export default function (definition) {
           const code = `['__${element.name}_page-number']() {
               return this['__${element.name}_params']?.number ?? 1
           }`
-          viewMethodData.push(code)
+          viewComputedData.push(code)
       } 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']() {
+          viewComputedData.push(`['__${element.name}_sorting']() {
               return {
                   field: undefined,
                   order: undefined

package/src/breakpoint/generator/AfterStartNode.ts

@@ -1,5 +1,4 @@
 import BreakpointNode from './BreakpointNode';
-import { getLogicAncestor } from '../shared/utils';
 
 export default class AfterStartNode extends BreakpointNode {
   _logicNodePath: string = '';
@@ -14,7 +13,7 @@ export default class AfterStartNode extends BreakpointNode {
     super.init();
 
     const { logic } = this;
-    const ancestor = getLogicAncestor(logic);
+    const ancestor = logic.getAncestor('Logic');
     this._logicNodePath = ancestor && ancestor.nodePath;
   }
 

package/src/breakpoint/generator/BeforeEndNode.ts

@@ -1,5 +1,4 @@
 import BreakpointNode from './BreakpointNode';
-import { getLogicAncestor } from '../shared/utils';
 
 export default class BeforeEndNode extends BreakpointNode {
   _logicNodePath: string = '';
@@ -14,7 +13,7 @@ export default class BeforeEndNode extends BreakpointNode {
     super.init();
 
     const { logic } = this;
-    const ancestor = getLogicAncestor(logic);
+    const ancestor = logic.getAncestor('Logic');
     this._logicNodePath = ancestor && ancestor.nodePath;
   }
 

package/src/breakpoint/generator/BreakpointNode.ts

@@ -72,14 +72,14 @@ const callLogicGenerator = (instance: BreakpointNode) => (breaker: string) => {
       return callback();
     }
 
-    const callNode = source.getCallNode() || {};
-    const { params: callNodeParams } = callNode;
+    const logic = source.getCallNode() || {};
+    const { params: logicParams } = logic;
 
-    const callNodeBase = callNodeParams || [];
-    callNode.params = callNodeBase.concat({ name: attribute });
+    const logicBase = logicParams || [];
+    logic.params = logicBase.concat({ name: attribute });
 
     const result = callback();
-    callNode.params = callNodeParams;
+    logic.params = logicParams;
 
     return result;
   };
@@ -90,7 +90,6 @@ const callLogicGenerator = (instance: BreakpointNode) => (breaker: string) => {
   const base = args || [];
 
   breakpointArgument.name = attribute;
-  breakpointArgument.keyword = attribute;
   breakpointArgument.expression = breakpointExpression as any;
   breakpointExpression._nodePath = _nodePath;
   source.arguments = base.concat(breakpointArgument);
@@ -117,46 +116,20 @@ const callFunctionGenerator = (instance: BreakpointNode) => (breaker: string) =>
     return;
   }
 
-  const {
-    arguments: sourceArguments,
-    typeArguments: sourceTypeArguments,
-  } = source;
+  const { typeArguments } = source;
 
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
   const breakpointExpression = new BreakpointNode();
   const breakpointArgument = new Argument();
-
-  const baseArguments = sourceArguments || [];
-  const baseTypeArguments = sourceTypeArguments || [];
-  const addToTypeArguments = baseTypeArguments?.length;
+  const base = typeArguments || [];
 
   breakpointArgument.name = attribute;
-  breakpointArgument.keyword = attribute;
   breakpointArgument.expression = breakpointExpression as any;
   breakpointExpression._nodePath = _nodePath;
-
-  if (addToTypeArguments) {
-    source.typeArguments = baseTypeArguments.concat(breakpointArgument);
-  } else {
-    const { length } = baseArguments;
-
-    if (length) {
-      const lastBaseArgument = baseArguments[length - 1];
-      const beforeBaseArguments = baseArguments.slice(0, -1);
-      const combinedLastBaseArgument = new BreakpointNode();
-
-      combinedLastBaseArgument.variable = lastBaseArgument;
-      combinedLastBaseArgument._nodePath = _nodePath;
-      source.arguments = beforeBaseArguments.concat(combinedLastBaseArgument);
-    } else {
-      source.arguments = baseArguments.concat(breakpointArgument);
-    }
-  }
+  source.typeArguments = base.concat(breakpointArgument);
 
   const code = source.toJS();
-
-  source.arguments = sourceArguments;
-  source.typeArguments = sourceTypeArguments;
+  source.typeArguments = typeArguments;
 
   return assemble(instance)(code);
 };

package/src/breakpoint/shared/constants.ts

@@ -1,12 +1,5 @@
 export const JSON_VOID = 'new String(\'void\')';
 
-export const LOGIC_CONCEPTS = [
-  'Logic',
-  'AuthLogic',
-  'OverriddenLogic',
-  'AuthLogicForCallInterface',
-] as const;
-
 export const VARIABLE_KEYS = [
   'test',
   'left',

package/src/breakpoint/shared/utils.ts

@@ -6,7 +6,6 @@ import {
 } from '../../concepts';
 
 import {
-  LOGIC_CONCEPTS,
   STATUS_ENABLED,
   STATUS_DISABLED,
   TRAVERSE_NODE_KEYS,
@@ -85,7 +84,6 @@ export const getRealNode = (node: BaseNode): BaseNode => {
 const unbrakableAncestors = [
   'Process',
   'BindAttribute',
-  'CallAuthInterface',
 ] as const;
 
 const isBreakableByAncestors = (node: BaseNode): Boolean => {
@@ -152,34 +150,14 @@ export const isDisabled = (node: BaseNode): Boolean => {
 
 export const getUniqueIdFromNode = (node: BaseNode) => node && node.nodePath;
 
-export const getGlobalLogics = (app: App) => {
-  if (!app) {
-    return [];
-  }
-
-  const {
-    logics = [],
-    authLogics = [],
-    overriddenLogics = [],
-    authLogicsForCallInterface = [],
-  } = app;
-
-  return [
-    ...(logics || []),
-    ...(authLogics || []),
-    ...(overriddenLogics || []),
-    ...(authLogicsForCallInterface || []),
-  ];
-};
-
 export const getLogics = (app: App) => {
   if (!app) {
     return [];
   }
 
-  const { frontends = [] } = app;
+  const { logics = [], frontends = [] } = app;
 
-  let result = getGlobalLogics(app) || [];
+  let result = logics;
 
   const forViewElement = (viewElement: ViewElement) => {
     if (!viewElement) {
@@ -227,7 +205,7 @@ export const getLogics = (app: App) => {
   frontends.forEach((frontend) => {
     const { views = [] } = frontend;
 
-    views && views.forEach(forView);
+    views.forEach(forView);
   });
 
   return result;
@@ -279,14 +257,3 @@ export const toString = (value: any, type: string) => {
 };
 
 export const toStringVoid = () => toString('void', 'undefined');
-
-export const getLogicAncestor = (node: BaseNode): BaseNode | undefined => {
-  if (!node) {
-    return;
-  }
-
-  return LOGIC_CONCEPTS.reduce(
-    (result, concpet) => result || node.getAncestor(concpet),
-    undefined,
-  ) as BaseNode | undefined;
-};