@lcap/nasl 3.2.0-beta.4 → 3.3.0-alpha

package/src/utils/string.ts

@@ -11,7 +11,8 @@ export const kebab2Camel = (name: string) => name.replace(/(?:^|-)([a-zA-Z0-9])/
  * @param notPascalCase = false 首字母是否小写
  * @return 转换后的名称
  */
-export const snake2Camel = (name: string, notPascalCase: boolean = false) => name.replace(/(?:^|_+?)([a-zA-Z0-9])/g, (m, $1, offset) => (notPascalCase && !offset) ? $1.toLowerCase() : $1.toUpperCase());
+export const snake2Camel = (name: string, notPascalCase: boolean = false) =>
+  name.replace(/(?:^|_+?)([a-zA-Z0-9])/g, (m, $1, offset) => (notPascalCase && !offset ? $1.toLowerCase() : $1.toUpperCase()));
 
 /**
  * 驼峰格式 转 中划线格式  camelCase -> kebab-case
@@ -43,54 +44,52 @@ export const firstLowerCase = (value: string) => value.replace(/^\S/, (letter) =
  * @param set 数据集合，Array | Map | Set
  * @param start 数字起始
  */
-export function unique(key: string,
-    set: Set<string> | Map<string, any> | Array<string> | { [name: string]: string },
-    start: number = 1,
-    insensitive: boolean = false) {
-    let has;
-    if (insensitive) {
-        has = (_key: string) => {
-            const lkey = _key.toLowerCase();
-            if (set instanceof Set || set instanceof Map) {
-                // return set.has(_key);
-                const iterator = set.keys();
-                let i = iterator.next();
-                while (!i.done) {
-                    const name = i.value;
-                    if (name.toLowerCase() === lkey) {
-                        return true;
-                    }
-                    i = iterator.next();
-                }
-                return false;
-            } else if (Array.isArray(set))
-                // return set.includes(_key);
-                return set.some((s) => s.toLowerCase() === lkey);
-            else {
-                // return set[_key];
-                const keys = Object.keys(set);
-                return keys.some((k) => k.toLowerCase() === lkey);
-            }
-        };
-    } else {
-        has = (_key: string) => {
-            if (set instanceof Set || set instanceof Map)
-                return set.has(_key);
-            else if (Array.isArray(set))
-                return set.includes(_key);
-            else
-                return set[_key];
-        };
-    }
+export function unique(
+  key: string,
+  set: Set<string> | Map<string, any> | Array<string> | { [name: string]: string },
+  start: number = 1,
+  insensitive: boolean = false
+) {
+  let has;
+  if (insensitive) {
+    has = (_key: string) => {
+      const lkey = _key.toLowerCase();
+      if (set instanceof Set || set instanceof Map) {
+        // return set.has(_key);
+        const iterator = set.keys();
+        let i = iterator.next();
+        while (!i.done) {
+          const name = i.value;
+          if (name.toLowerCase() === lkey) {
+            return true;
+          }
+          i = iterator.next();
+        }
+        return false;
+      }
+      if (Array.isArray(set))
+        // return set.includes(_key);
+        return set.some((s) => s.toLowerCase() === lkey);
 
-    while (has(key))
-        key = key.replace(/\d*$/, (m) => String(m === '' ? start : +m + 1));
-    return key;
+      // return set[_key];
+      const keys = Object.keys(set);
+      return keys.some((k) => k.toLowerCase() === lkey);
+    };
+  } else {
+    has = (_key: string) => {
+      if (set instanceof Set || set instanceof Map) return set.has(_key);
+      if (Array.isArray(set)) return set.includes(_key);
+      return set[_key];
+    };
+  }
+
+  while (has(key)) key = key.replace(/\d*$/, (m) => String(m === '' ? start : +m + 1));
+  return key;
 }
 
 export const getLastOfPath = (path: string) => {
-    const arr = path.split('/');
-    return arr[arr.length - 1];
+  const arr = path.split('/');
+  return arr[arr.length - 1];
 };
 
 /**
@@ -100,7 +99,7 @@ export const getLastOfPath = (path: string) => {
  * @param attrs 属性匹配
  */
 export const sliceTagContent = (source: string, tag: string, attrs: string = '') => {
-    const reg = new RegExp(`<${tag}${attrs ? ' ' + attrs : ''}.*?>([\\s\\S]+)<\\/${tag}>`);
-    const m = source.match(reg);
-    return m ? m[1].replace(/^\n+/, '') : '';
+  const reg = new RegExp(`<${tag}${attrs ? ` ${attrs}` : ''}.*?>([\\s\\S]+)<\\/${tag}>`);
+  const m = source.match(reg);
+  return m ? m[1].replace(/^\n+/, '') : '';
 };

package/src/utils/time-slicing.ts

@@ -0,0 +1,109 @@
+/** 时间分片选项 */
+export interface TimeSlicingOption {
+  /**
+   * 最小每帧任务数
+   * @description 每帧运行任务数量的下限，也作为起始数量值
+   * @default 10
+   */
+  minimum: number;
+  /**
+   * 增长系数
+   * @default 1.3
+   */
+  increase: number;
+  /**
+   * 缩减系数
+   * @default 0.5
+   */
+  decrease: number;
+  /**
+   * 每帧时间上限
+   * @default 24
+   */
+  frameTime: number;
+}
+
+/**
+ * 时间分片
+ *
+ * @description 使用 requestAnimationFrame API 来实现大型任务的分片执行保证不阻塞主线程
+ * @param {T[]} list - 项目列表
+ * @param {(val: T, index: number) => void} cb - 每个项目的回调
+ * @param {Partial<TimeSlicingOption>} [opt] - 分片参数
+ */
+export function timeSlicing<T>(list: T[], cb: (val: T, index: number) => void, opt: Partial<TimeSlicingOption> = {}): Promise<void> {
+  // node 环境不需要进行切片
+  if (process.env.BUILD_TARGET === 'node') {
+    list.forEach((item, i) => cb(item, i));
+    return;
+  }
+
+  const listSlice = list.slice();
+  /** 每帧时间上限 */
+  const frameTimeLimit = opt.frameTime ?? 24;
+  /** 增大比例 */
+  const increaseRatio = opt.increase ?? 1.2;
+  /** 缩小比例 */
+  const decreaseRatio = opt.decrease ?? 0.5;
+  /** 每组的最小值 */
+  const smallLimit = opt.minimum ?? 10;
+  /** 当前处理数据数量 */
+  let currentNumber = opt.minimum ?? 10;
+  /** 上一帧的时间 */
+  let lastTime = 0;
+  /** 上一次处理最后元素的下标 */
+  let lastIndex = 0;
+
+  return new Promise<void>((resolve, reject) => {
+    function loop(nowTime: number) {
+      // 待处理数据为空，则完成执行
+      if (listSlice.length === 0) {
+        resolve();
+        return;
+      }
+
+      const diffTime = nowTime - lastTime;
+
+      currentNumber = lastTime === 0 ? currentNumber : Math.round(currentNumber * (diffTime > frameTimeLimit ? decreaseRatio : increaseRatio));
+
+      if (currentNumber < smallLimit) {
+        currentNumber = smallLimit;
+      }
+
+      const len = currentNumber < listSlice.length ? currentNumber : listSlice.length;
+      const currentArr = listSlice.splice(0, currentNumber);
+
+      for (let i = 0; i < len; i++) {
+        try {
+          cb(currentArr[i], lastIndex + i);
+        } catch (e) {
+          reject(e);
+        }
+      }
+
+      lastIndex += currentNumber;
+      lastTime = nowTime;
+      requestAnimationFrame(loop);
+    }
+
+    requestAnimationFrame(loop);
+  });
+}
+
+/**
+ * 固定时间分片
+ *
+ * @description 使用 requestAnimationFrame API 来实现大型任务的分片执行保证不阻塞主线程
+ */
+export function constantTimeSlice<T>(list: T[], sliceCount: number, cb: (val: T, index: number) => void): Promise<void> {
+  return timeSlicing(list, cb, {
+    minimum: sliceCount,
+    increase: 1,
+    decrease: 1,
+  });
+}
+
+/** 延迟 */
+export function delay(time: number = 10) {
+  return new Promise<void>((resolve) => setTimeout(resolve, time));
+}

package/src/utils/traverse.ts

@@ -2,138 +2,127 @@
  * 用于遍历的节点接口
  */
 export interface INode {
-    children?: Array<INode>;
-    [prop: string]: any;
+  children?: Array<INode>;
+  [prop: string]: any;
 }
 /**
  * 用于遍历的节点信息
  */
 export interface INodeInfo<T extends INode> {
-    node: T;
-    parent?: T;
-    stack?: Array<T>;
-    nodePath?: string;
-    jsonPath?: string;
-    index?: number;
-    key?: string | number;
+  node: T;
+  parent?: T;
+  stack?: Array<T>;
+  nodePath?: string;
+  jsonPath?: string;
+  index?: number;
+  key?: string | number;
 }
 
 export interface TraverseOptions {
-    mode?: 'onlyChildren' | 'onlyArray' | 'anyObject';
-    depthFirst?: boolean;
-    backTracking?: boolean;
-    excludedKeySet?: Set<string>;
+  mode?: 'onlyChildren' | 'onlyArray' | 'anyObject';
+  depthFirst?: boolean;
+  backTracking?: boolean;
+  excludedKeySet?: Set<string>;
 }
 
-const EXCLUDE_RULES = [
-    /^__.*__$/,
-]
+const EXCLUDE_RULES = [/^__.*__$/];
 
 function isExcludeProperty(propertyName: string) {
-    return EXCLUDE_RULES.some(r => r.test(propertyName));
+  return EXCLUDE_RULES.some((r) => r.test(propertyName));
 }
 
 function handleNext<T extends INode>(func: (next: INodeInfo<T>) => any, current: INodeInfo<T>, options?: TraverseOptions) {
-    if (options.mode === 'onlyChildren') {
-        const list = current.node && current.node.children;
-        if (!list)
-            return;
+  if (options.mode === 'onlyChildren') {
+    const list = current.node && current.node.children;
+    if (!list) return;
 
-        for (let index = 0; index < list.length; index++) {
-            const child = list[index];
-            if (!child)
-                continue;
+    for (let index = 0; index < list.length; index++) {
+      const child = list[index];
+      if (!child) continue;
 
-            const nodeInfo: INodeInfo<T> = {
-                node: child as T,
-                parent: current.node,
-                stack: current.stack.concat([current.node]),
-                nodePath: `${current.nodePath}/${index}`,
-                jsonPath: `${current.jsonPath}.children[${index}]`.replace(/^\./, ''),
-                index,
-                key: index,
-            };
-            const result = func(nodeInfo);
-            // if (result !== undefined)
-            //     return result;
-        }
-    } else if (options.mode === 'onlyArray') {
-        for (const key in current.node) {
-            if (!current.node.hasOwnProperty(key) || options.excludedKeySet.has(key) || isExcludeProperty(key))
-                continue;
-            const value = current.node[key];
-            if (!Array.isArray(value))
-                continue;
+      const nodeInfo: INodeInfo<T> = {
+        node: child as T,
+        parent: current.node,
+        stack: current.stack.concat([current.node]),
+        nodePath: `${current.nodePath}/${index}`,
+        jsonPath: `${current.jsonPath}.children[${index}]`.replace(/^\./, ''),
+        index,
+        key: index,
+      };
+      const result = func(nodeInfo);
+      // if (result !== undefined)
+      //     return result;
+    }
+  } else if (options.mode === 'onlyArray') {
+    for (const key in current.node) {
+      if (!current.node.hasOwnProperty(key) || options.excludedKeySet.has(key) || isExcludeProperty(key)) continue;
+      const value = current.node[key];
+      if (!Array.isArray(value)) continue;
 
-            const list = value;
-            for (let index = 0; index < list.length; index++) {
-                const child = list[index];
-                if (!child)
-                    continue;
+      const list = value;
+      for (let index = 0; index < list.length; index++) {
+        const child = list[index];
+        if (!child) continue;
 
-                const nodeInfo: INodeInfo<T> = {
-                    node: child as T,
-                    parent: current.node,
-                    stack: current.stack.concat([current.node]),
-                    nodePath: `${current.nodePath}/${index}`,
-                    jsonPath: `${current.jsonPath}.${key}[${index}]`.replace(/^\./, ''),
-                    index,
-                    key: index,
-                };
-                const result = func(nodeInfo);
-                // if (result !== undefined)
-                //     return result;
-            }
-        }
-    } else if (options.mode === 'anyObject') {
-        for (const key in current.node) {
-            if (!current.node.hasOwnProperty(key) || options.excludedKeySet.has(key) || isExcludeProperty(key))
-                continue;
-            const value = current.node[key];
-            if (Array.isArray(value)) {
-                const list = value;
-                for (let index = 0; index < list.length; index++) {
-                    const child = list[index];
-                    if (!child)
-                        continue;
+        const nodeInfo: INodeInfo<T> = {
+          node: child as T,
+          parent: current.node,
+          stack: current.stack.concat([current.node]),
+          nodePath: `${current.nodePath}/${index}`,
+          jsonPath: `${current.jsonPath}.${key}[${index}]`.replace(/^\./, ''),
+          index,
+          key: index,
+        };
+        const result = func(nodeInfo);
+        // if (result !== undefined)
+        //     return result;
+      }
+    }
+  } else if (options.mode === 'anyObject') {
+    for (const key in current.node) {
+      if (!current.node.hasOwnProperty(key) || options.excludedKeySet.has(key) || isExcludeProperty(key)) continue;
+      const value = current.node[key];
+      if (Array.isArray(value)) {
+        const list = value;
+        for (let index = 0; index < list.length; index++) {
+          const child = list[index];
+          if (!child) continue;
 
-                    const nodeInfo: INodeInfo<T> = {
-                        node: child as T,
-                        parent: current.node,
-                        stack: current.stack.concat([current.node]),
-                        nodePath: `${current.nodePath}/${index}`,
-                        jsonPath: `${current.jsonPath}.${key}[${index}]`.replace(/^\./, ''),
-                        index,
-                        key: index,
-                    };
-                    const result = func(nodeInfo);
-                    // if (result !== undefined)
-                    //     return result;
-                }
-            } else if (typeof value === 'object' && value !== null) {
-                const nodeInfo: INodeInfo<T> = {
-                    node: value as T,
-                    parent: current.node,
-                    stack: current.stack.concat([current.node]),
-                    nodePath: `${current.nodePath}/${key}`,
-                    jsonPath: `${current.jsonPath}['${key}']`,
-                    index: undefined,
-                    key,
-                };
-                const result = func(nodeInfo);
-                // if (result !== undefined)
-                //     return result;
-            }
+          const nodeInfo: INodeInfo<T> = {
+            node: child as T,
+            parent: current.node,
+            stack: current.stack.concat([current.node]),
+            nodePath: `${current.nodePath}/${index}`,
+            jsonPath: `${current.jsonPath}.${key}[${index}]`.replace(/^\./, ''),
+            index,
+            key: index,
+          };
+          const result = func(nodeInfo);
+          // if (result !== undefined)
+          //     return result;
         }
+      } else if (typeof value === 'object' && value !== null) {
+        const nodeInfo: INodeInfo<T> = {
+          node: value as T,
+          parent: current.node,
+          stack: current.stack.concat([current.node]),
+          nodePath: `${current.nodePath}/${key}`,
+          jsonPath: `${current.jsonPath}['${key}']`,
+          index: undefined,
+          key,
+        };
+        const result = func(nodeInfo);
+        // if (result !== undefined)
+        //     return result;
+      }
     }
+  }
 }
 
 function checkCircular<T>(next: INodeInfo<T>) {
-    if (next.stack.length > 100 || Number(next.key) > 10000 || next.index > 10000)
-        console.error(next);
-    if (next.stack.length > 110 || Number(next.key) > 10010 || next.index > 10010)
-        throw new Error('Circular traverse!');
-    return next.stack.includes(next.node);
+  if (next.stack.length > 100 || Number(next.key) > 10000 || next.index > 10000) console.error(next);
+  if (next.stack.length > 110 || Number(next.key) > 10010 || next.index > 10010) throw new Error('Circular traverse!');
+  return next.stack.includes(next.node);
 }
 /**
  * 遍历树
@@ -145,29 +134,28 @@ function checkCircular<T>(next: INodeInfo<T>) {
  * @example traverse((current) => console.log(current.jsonPath), { init: ast }, { mode: 'anyObject' });
  */
 export function traverse<T extends INode>(func: (current: INodeInfo<T>) => any, init: INodeInfo<T>, options?: TraverseOptions) {
-    init = Object.assign({ parent: undefined, stack: [], nodePath: '', jsonPath: '', index: undefined }, init);
-    options = Object.assign({ mode: 'onlyChildren', depthFirst: false, backTracking: false, excludedKeySet: new Set() }, options);
+  init = { parent: undefined, stack: [], nodePath: '', jsonPath: '', index: undefined, ...init };
+  options = { mode: 'onlyChildren', depthFirst: false, backTracking: false, excludedKeySet: new Set(), ...options };
 
-    if (options.depthFirst) {
-        if (options.backTracking) {
-            handleNext<T>((next) => !checkCircular(next) && traverse(func, next, options), init, options);
-            func(init);
-        } else {
-            func(init);
-            handleNext<T>((next) => !checkCircular(next) && traverse(func, next, options), init, options);
-        }
+  if (options.depthFirst) {
+    if (options.backTracking) {
+      handleNext<T>((next) => !checkCircular(next) && traverse(func, next, options), init, options);
+      func(init);
     } else {
-        let queue: Array<INodeInfo<T>> = [];
-        queue = queue.concat(init);
-        let current: INodeInfo<T>;
-        while ((current = queue.shift())) {
-            const result = func(current);
-            if (result !== undefined)
-                return result;
+      func(init);
+      handleNext<T>((next) => !checkCircular(next) && traverse(func, next, options), init, options);
+    }
+  } else {
+    let queue: Array<INodeInfo<T>> = [];
+    queue = queue.concat(init);
+    let current: INodeInfo<T>;
+    while ((current = queue.shift())) {
+      const result = func(current);
+      if (result !== undefined) return result;
 
-            handleNext<T>((next) => !checkCircular(next) && queue.push(next), current, options);
-        }
+      handleNext<T>((next) => !checkCircular(next) && queue.push(next), current, options);
     }
+  }
 }
 
 export default traverse;

package/test/concepts/match/__snapshots__/toEmbeddedTS.spec.ts.snap

@@ -0,0 +1,66 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`match:toEmbeddedTS isExpression 1`] = `
+"(() => {
+  variable1;
+  function __MatchExpressionFuntion() {
+    if (nasl.core.isUnionType<typeof variable1, nasl.core.Boolean>(variable1)) {
+      return;
+    }
+
+    if (nasl.core.isUnionType<typeof variable1, nasl.core.Long>(variable1)) {
+      return new nasl.core.Long(0);
+    }
+
+    if (nasl.core.isUnionType<typeof variable1, nasl.core.String>(variable1)) {
+      return new nasl.core.String(\\"StringLiteral\\");
+    } else {
+    }
+  }
+  return __MatchExpressionFuntion();
+})();
+"
+`;
+
+exports[`match:toEmbeddedTS lastBodyIf 1`] = `
+"(() => {
+  variable1;
+  function __MatchExpressionFuntion() {
+    if (nasl.core.isUnionType<typeof variable1, nasl.core.Boolean>(variable1)) {
+      if (nasl.core.ensureBoolean(variable1)) {
+      } else {
+      }
+    }
+
+    if (nasl.core.isUnionType<typeof variable1, nasl.core.Long>(variable1)) {
+      while (nasl.core.ensureBoolean(variable1)) {}
+    }
+
+    if (nasl.core.isUnionType<typeof variable1, nasl.core.String>(variable1)) {
+      nasl.logging.INFO(nasl.util.stringInterpolation(variable1));
+    } else {
+    }
+  }
+  return __MatchExpressionFuntion();
+})();
+"
+`;
+
+exports[`match:toEmbeddedTS noExpression 1`] = `
+"(() => {
+  variable2;
+  function __MatchExpressionFuntion() {
+    if (
+      variable2 === app.enums.UserStatusEnum[\\"Normal\\"] ||
+      variable2 === app.enums.UserStatusEnum[\\"Forbidden\\"]
+    ) {
+    }
+
+    if (variable2 === app.enums.UserStatusEnum[\\"Forbidden\\"]) {
+    } else {
+    }
+  }
+  return __MatchExpressionFuntion();
+})();
+"
+`;

package/test/concepts/match/__snapshots__/toJS.spec.ts.snap

@@ -0,0 +1,40 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`match:toJS isExpression 1`] = `
+"await(async () => {
+  if (this.$isInstanceOf(variable1, \\"nasl.core.Boolean\\")) {
+    throw Error(\\"程序中止\\");
+  } else if (this.$isInstanceOf(variable1, \\"nasl.core.Long\\")) {
+    return 0;
+  } else if (this.$isInstanceOf(variable1, \\"nasl.core.String\\")) {
+    return \`\`;
+  } else {
+  }
+})();
+"
+`;
+
+exports[`match:toJS lastBodyIf 1`] = `
+"if (this.$isInstanceOf(variable1, \\"nasl.core.Boolean\\")) {
+  if (variable1) {
+  } else {
+  }
+} else if (this.$isInstanceOf(variable1, \\"nasl.core.Long\\")) {
+  while (variable1) {}
+} else if (this.$isInstanceOf(variable1, \\"nasl.core.String\\")) {
+  await(this.INFO(this.$utils[\\"ToString\\"](variable1, \\"undefined\\")));
+} else {
+}
+"
+`;
+
+exports[`match:toJS noExpression 1`] = `
+"if (
+  this.$global.isEqual(variable2, \\"Normal\\") ||
+  this.$global.isEqual(variable2, \\"Forbidden\\")
+) {
+} else if (this.$global.isEqual(variable2, \\"Forbidden\\")) {
+} else {
+}
+"
+`;

package/test/concepts/match/constant.ts

@@ -0,0 +1,5 @@
+import { basename } from 'path';
+import { getCases } from '../utils';
+
+export const ConceptName = basename(__dirname);
+export const cases = getCases(ConceptName);