@lcap/nasl 3.4.0-beta.5 → 3.4.0-beta.6

package/src/utils/time-slicing/controller.ts

@@ -0,0 +1,342 @@
+import { pageIsActive } from './page-state';
+import { Performance } from './performance';
+import {
+  getFrameMark,
+  getGroupMark,
+  getAsyncMark,
+  GroupData,
+  FrameData,
+  AsyncData,
+  getId,
+} from './utils';
+import {
+  LowResourceRatio,
+  FrameMinTime,
+  FrameIdleTime,
+  NextState,
+  TheoreticalLimitCalculationCoefficient as Coefficient,
+} from './constant';
+
+/** 时间分片控制器 */
+export class TimeSlicingController {
+  /** 控制器编号 */
+  private id = getId();
+
+  /** 已处理的任务数量 */
+  private allTaskNumber = 0;
+
+  /**
+   * 已处理任务消耗的总时间
+   *
+   * @description 单位“毫秒”
+   */
+  private allTaskTime = 0;
+
+  /**
+   * 单个任务平均执行时间
+   *
+   * @description 单位“毫秒”，初始化为`1`微秒
+   */
+  private averageTaskTime = 1e-3;
+
+  /** 资源不足帧的数量 */
+  private lowResourceFrame = 0;
+
+  /** 帧数据 */
+  private readonly frame: FrameData = {
+    id: 0,
+    time: 0,
+    groupTime: 0,
+    mark: getFrameMark(0),
+  };
+
+  /** 任务组数据 */
+  private readonly group: GroupData = {
+    id: 0,
+    time: 0,
+    limit: 1,
+    frameId: 1,
+    mark: getGroupMark(0),
+  };
+
+  /** 异步等待数据 */
+  private readonly async: AsyncData = {
+    id: 0,
+    time: 0,
+    result: undefined,
+    mark: getAsyncMark(0),
+  };
+
+  /** 性能检测包装器 */
+  private readonly performance = new Performance(this.id);
+
+  /// #if process.env.NODE_ENV === 'development'
+  private groupList: GroupData[] = [];
+  private frameList: FrameData[] = [];
+  private asyncList: AsyncData[] = [];
+  /// #endif
+
+  /** 任务增长系数 */
+  private increaseRatio(now: number) {
+    if (now <= 0) {
+      return 1;
+    }
+    else if (this.allTaskTime < 0.01) {
+      return now * 10;
+    }
+    else if (now < 10) {
+      return now * 2;
+    }
+    else {
+      return now * 1.3;
+    }
+  }
+
+  /** 下组任务状态 */
+  private getNextData() {
+    const { frame, group, async } = this;
+
+    // 页面处于活动状态
+    if (pageIsActive) {
+      /** 帧剩余时间 */
+      const restFrameTime = Math.max(FrameMinTime - async.time - frame.time, 0);
+      /** 是否使用下一帧 */
+      const useNextFrame = restFrameTime < FrameIdleTime;
+      const state = useNextFrame ? NextState.NextFrame : NextState.MicroTask;
+      /** 增长系数计算的任务上限 */
+      const taskNumberByRatio = this.increaseRatio(group.limit);
+      /** 理论上限 */
+      const taskNumberByTheoretical = useNextFrame
+        ? Math.round((FrameMinTime - FrameIdleTime) / this.averageTaskTime * Coefficient)
+        : Math.round(restFrameTime / this.averageTaskTime * Coefficient);
+      /** 实际应该使用的任务上限 */
+      const realTaskNumber = Math.floor(
+        taskNumberByTheoretical <= 0
+          ? 1
+          : taskNumberByTheoretical < taskNumberByRatio
+            ? taskNumberByTheoretical
+            : taskNumberByRatio
+      );
+
+      return {
+        next: state,
+        task: realTaskNumber,
+      };
+    }
+    // 页面在后台时，不需要顾忌 UI 渲染，全速跑即可
+    else {
+      return {
+        next: NextState.MicroTask,
+        task: Math.round(FrameMinTime / this.averageTaskTime),
+      };
+    }
+  }
+
+  /** 清除状态 */
+  private clearState() {
+    this.performance.clear();
+  }
+
+  /** 展示信息 */
+  private displayInfo() {
+    // 调试用的代码，别删
+    // console.log('时间分片完成', {
+    //   '任务数': this.allTaskNumber,
+    //   '单任务平均耗时': this.averageTaskTime,
+    //   '任务组数据': this.groupList,
+    //   '帧数据': this.frameList,
+    //   '异步等待数据': this.asyncList,
+    // });
+  }
+
+  /** 当前组运行开始 */
+  private setGroupStart() {
+    const { group, frame, performance } = this;
+
+    group.id++;
+    group.time = 0;
+    group.frameId = frame.id;
+    group.mark = getGroupMark(group.id);
+
+    performance.mark(group.mark.GroupStart);
+  }
+
+  /** 当前组运行结束 */
+  private setGroupEnd() {
+    const { group, frame, performance } = this;
+
+    performance.mark(group.mark.GroupEnd);
+    /** 当前微任务的运行时间 */
+    const groupMeasure = performance.measure(group.mark.GroupMeasure, group.mark.GroupStart, group.mark.GroupEnd);
+    /** 当前帧的运行时间 */
+    const frameMeasure = performance.measure(frame.mark.FrameMeasure, frame.mark.FrameStart, group.mark.GroupEnd);
+
+    performance.clearByNames(group.mark.GroupStart, group.mark.GroupEnd);
+    performance.clearByNames(group.mark.GroupMeasure, frame.mark.FrameMeasure);
+
+    group.time = groupMeasure.duration;
+    frame.time = frameMeasure.duration;
+
+    this.frame.groupTime += groupMeasure.duration;
+    this.allTaskNumber += group.limit;
+    this.allTaskTime += groupMeasure.duration;
+    this.averageTaskTime = this.allTaskTime / this.allTaskNumber;
+
+    /// #if process.env.NODE_ENV === 'development'
+    this.groupList.push({ ...group });
+    /// #endif
+  }
+
+  /** 动画帧开始 */
+  private setFrameStart() {
+    const { frame, performance } = this;
+
+    frame.id++;
+    frame.groupTime = 0;
+    frame.mark = getFrameMark(frame.id);
+    performance.clear();
+    performance.mark(frame.mark.FrameStart);
+  }
+
+  /** 动画帧结束 */
+  private setFrameEnd() {
+    const { frame } = this;
+
+    /// #if process.env.NODE_ENV === 'development'
+    this.frameList.push({ ...this.frame });
+    /// #endif
+
+    // 资源不足
+    if ((frame.groupTime / frame.time) < LowResourceRatio) {
+      this.lowResourceFrame++;
+    }
+  }
+
+  /** 异步等待开始 */
+  private setAsyncStart() {
+    const { async, performance } = this;
+
+    async.id++;
+    async.time = 0;
+    async.mark = getAsyncMark(async.id);
+    performance.mark(async.mark.AsyncStart);
+  }
+
+  /** 异步等待结束 */
+  private setAsyncEnd() {
+    const { async, performance } = this;
+
+    performance.mark(async.mark.AsyncEnd);
+    async.time = performance.measure(async.mark.AsyncMeasure, async.mark.AsyncStart, async.mark.AsyncEnd).duration;
+    performance.clearByNames(async.mark.AsyncStart, async.mark.AsyncEnd, async.mark.AsyncMeasure);
+
+    /// #if process.env.NODE_ENV === 'development'
+    this.asyncList.push({ ...async });
+    /// #endif
+  }
+
+  run<T = void>(generator: Generator<any, T, void>): Promise<T> {
+    return new Promise<T>((resolve) => {
+      /** 生成器结果 */
+      let result: IteratorResult<void, any> = {
+        done: false,
+        value: undefined,
+      };
+      /** 异步运行标志 */
+      let waitAsync = false;
+
+      const { group } = this;
+      const isPromise = (input: unknown): input is Promise<any> => input && input instanceof Promise;
+
+      /** 运行帧 */
+      const runFrame = () => {
+        this.setFrameStart();
+        runGroup();
+      };
+      /** 运行下组任务 */
+      const runNextGroup = () => {
+        const { next, task } = this.getNextData();
+
+        group.limit = task;
+
+        if (next === NextState.MicroTask) {
+          Promise.resolve().then(runGroup);
+        }
+        else {
+          this.setFrameEnd();
+          requestAnimationFrame(runFrame);
+        }
+      };
+      /** 运行任务组 */
+      const runGroup = () => {
+        this.setGroupStart();
+        runGroupTask();
+        this.setGroupEnd();
+
+        // 等待异步任务
+        if (waitAsync) {
+          return;
+        }
+
+        // 结束运行
+        if (result.done) {
+          this.clearState();
+          /// #if process.env.NODE_ENV === 'development'
+          this.displayInfo();
+          console.timeEnd(`时间分片-${this.id}`);
+          /// #endif
+          resolve(result.value);
+          return;
+        }
+
+        runNextGroup();
+      };
+      /** 运行异步任务 */
+      const runAsyncTask = (param: unknown) => {
+        this.setAsyncEnd();
+        this.async.result = param;
+        runNextGroup();
+        waitAsync = false;
+        this.async.time = 0;
+      };
+      /** 运行任务 */
+      const runGroupTask = () => {
+        let taskId = 0;
+
+        while (!result.done && taskId < group.limit) {
+          const lastIsPromise = isPromise(result.value);
+          const lastParam = lastIsPromise ? this.async.result : result.value;
+
+          taskId++;
+          result = generator.next(lastParam);
+
+          // 运行完毕
+          if (result.done || taskId >= group.limit) {
+            break;
+          }
+
+          // 返回 Promise 时，等待异步任务完成
+          if (isPromise(result.value)) {
+            waitAsync = true;
+            this.setAsyncStart();
+            result.value
+              .then(runAsyncTask)
+              .catch(error => generator.throw(error));
+
+            break;
+          }
+        }
+
+        // 记录实际运行数量
+        group.limit = taskId;
+      };
+
+      /// #if process.env.NODE_ENV === 'development'
+      console.time(`时间分片-${this.id}`);
+      /// #endif
+
+      // 启动分片
+      runFrame();
+    });
+  }
+}

package/src/utils/time-slicing/index.ts

@@ -0,0 +1,6 @@
+export { delay, isGenerator, returnOrigin } from './utils';
+
+export * from './runner';
+export * from './wrapper';
+export * from './tool';
+export * from './controller';

package/src/utils/time-slicing/page-state.ts

@@ -0,0 +1,12 @@
+import { isNode } from '../env';
+
+/** 页面活动状态 */
+export let pageIsActive = false;
+
+// 浏览器环境需要监听页面活动状态
+if (!isNode) {
+  pageIsActive = !(document?.hidden ?? true);
+  document?.addEventListener('visibilitychange', () => {
+    pageIsActive = !document.hidden;
+  });
+}

package/src/utils/time-slicing/performance.ts

@@ -0,0 +1,56 @@
+enum EntryType {
+  mark = 'mark',
+  measure = 'measure',
+}
+
+export class Performance {
+  private id: number;
+
+  constructor(id: number) {
+    this.id = id;
+  }
+
+  get prefix() {
+    return `[time-slicing]-${this.id}`;
+  }
+
+  private getPerformanceId(name: string) {
+    return `${this.prefix}-${name}`;
+  }
+
+  private clearEntry(entry: PerformanceEntry) {
+    if (entry.entryType === EntryType.mark) {
+      performance.clearMarks(entry.name);
+    }
+    else if (entry.entryType === EntryType.measure) {
+      performance.clearMeasures(entry.name);
+    }
+  }
+
+  mark(name: string) {
+    return performance.mark(this.getPerformanceId(name));
+  }
+
+  measure(name: string, startMark: string, endMark: string) {
+    return performance.measure(this.getPerformanceId(name), this.getPerformanceId(startMark), this.getPerformanceId(endMark));
+  }
+
+  clearByNames(...names: string[]) {
+    for (const name of names) {
+      const entry = performance.getEntriesByName(this.getPerformanceId(name))[0];
+
+      if (entry) {
+        this.clearEntry(entry);
+      }
+    }
+  }
+
+  clear() {
+    const { prefix } = this;
+
+    performance.getEntries()
+      .filter((item) => item.entryType === EntryType.mark || item.entryType === EntryType.measure)
+      .filter((item) => item.name.startsWith(prefix))
+      .forEach((entry) => this.clearEntry(entry));
+  }
+}

package/src/utils/time-slicing/runner.ts

@@ -0,0 +1,54 @@
+/**
+ * 运行生成器
+ *
+ * @description 同步模式
+ */
+export function runGeneratorSync<T = void>(generator: Generator<any, T, any>) {
+  let result = generator.next();
+  while (!result.done) {
+    result = generator.next(result.value);
+  }
+  return result.value;
+}
+
+/**
+ * 运行生成器
+ *
+ * @description 异步模式
+ */
+export function runGeneratorAsync<T = void>(generator: Generator<any, T, any>): Promise<T> {
+  return new Promise<T>((resolve) => {
+    let result: IteratorResult<any, T> = {
+      done: false,
+      value: undefined,
+    };
+
+    function isPromise(input: unknown): input is Promise<any> {
+      return input && input instanceof Promise;
+    }
+
+    function runAsync(param: unknown) {
+      result.value = param;
+      run();
+    }
+
+    function run() {
+      while (!result.done && !isPromise(result.value)) {
+        result = generator.next(result.value);
+      }
+
+      if (result.done) {
+        resolve(result.value);
+        return;
+      }
+
+      if (isPromise(result.value)) {
+        result.value
+          .then(runAsync)
+          .catch(error => generator.throw(error));
+      }
+    }
+
+    run();
+  });
+}

package/src/utils/time-slicing/tool.ts

@@ -0,0 +1,45 @@
+import { isNode } from '../env';
+import { TimeSlicingController } from './controller';
+import { runGeneratorAsync as runAsync } from './runner';
+import { wrapForEachToGenerator } from './wrapper';
+
+/**
+ * 时间分片
+ *
+ * @description 大型任务分片执行，保证不阻塞主线程
+ * @description 数组回调必须是同步的，若是想要使用异步回调，请使用`timeSlicingWithGenerator`方法
+ * @param {T[]} list - 项目列表
+ * @param {(val: T, index: number) => void} cb - 每个项目的回调
+ */
+export function timeSlicingWithList<T>(list: T[], cb: (val: T, index: number, arr: T[]) => void): Promise<void> {
+  // node 环境不需要进行切片
+  if (isNode) {
+    list.forEach((item, i) => cb(item, i, list));
+    return Promise.resolve();
+  }
+
+  return new TimeSlicingController().run(wrapForEachToGenerator(list, cb));
+}
+
+/**
+ * 生成器时间分片
+ *
+ * @description 大型任务的分片执行保证不阻塞主线程
+ * @description 生成器中允许使用异步操作，使用`yield [promise]`语句即可
+ * @example
+ * ```
+ * timeSlicingWithGenerator((function test() {
+ *   const result = yield axios.get('xxxxxx');
+ *   console.log(result);
+ * })());
+ * ```
+ * @param {Generator<any, T, any>} generator - 生成器
+ */
+export function timeSlicingWithGenerator<T = void>(generator: Generator<any, T, any>) {
+  // node 环境不需要进行切片
+  if (isNode) {
+    return runAsync<T>(generator);
+  }
+
+  return new TimeSlicingController().run(generator);
+}

package/src/utils/time-slicing/utils.ts

@@ -0,0 +1,90 @@
+export interface TaskDataInDebug {
+  count: number;
+  time: number;
+  avg: number;
+  frameId: number;
+}
+
+export interface GroupData {
+  /** 任务组编号 */
+  id: number;
+  /** 所属帧编号 */
+  frameId: number;
+  /** 任务组耗时 */
+  time: number;
+  /** 任务组数量 */
+  limit: number;
+  /** 任务组标签 */
+  mark: ReturnType<typeof getGroupMark>;
+}
+
+export interface FrameData {
+  /** 帧编号 */
+  id: number;
+  /** 帧耗时 */
+  time: number;
+  /** 任务组在当前帧的耗时 */
+  groupTime: number;
+  /** 帧标签 */
+  mark: ReturnType<typeof getFrameMark>;
+}
+
+export interface AsyncData {
+  /** 异步等待编号 */
+  id: number;
+  /** 异步等待耗时 */
+  time: number;
+  /** 异步结果 */
+  result: any;
+  /** 异步标签 */
+  mark: ReturnType<typeof getAsyncMark>;
+}
+
+/** 编号 */
+let id = 0;
+
+export function getId() {
+  return id++;
+}
+
+/** 延迟 */
+export function delay(time: number = 10) {
+  return new Promise<void>((resolve) => setTimeout(resolve, time));
+}
+
+export function getAsyncMark(id: number) {
+  return {
+    AsyncStart: `AsyncStart-${id}`,
+    AsyncEnd: `AsyncEnd-${id}`,
+    AsyncMeasure: `AsyncMeasure-${id}`,
+  };
+}
+
+export function getGroupMark(id: number) {
+  return {
+    GroupStart: `GroupStart-${id}`,
+    GroupEnd: `GroupEnd-${id}`,
+    GroupMeasure: `GroupMeasure-${id}`,
+  };
+}
+
+export function getFrameMark(id: number) {
+  return {
+    FrameStart: `FrameStart-${id}`,
+    FrameEnd: `FrameEnd-${id}`,
+    FrameMeasure: `FrameMeasure-${id}`,
+  };
+}
+
+export function isGenerator(value: unknown): value is Generator<any, any, any> {
+  return value && typeof (value as any)[Symbol.iterator] === 'function';
+}
+
+/**
+ * 空生成器
+ */
+export function returnOrigin(): Generator<any, void, any>;
+export function returnOrigin<T>(defaultVal: T): Generator<any, T, any>
+export function* returnOrigin<T>(defaultVal?: T): Generator<any, any, any> {
+  return defaultVal;
+}

package/src/utils/time-slicing/wrapper.ts

@@ -0,0 +1,58 @@
+import { isGenerator } from './utils';
+
+/**
+ * 迭代器包装为生成器
+ *
+ * @description 回调中允许使用生成器
+ */
+export function wrapIteratorToGenerator<T>(list: IterableIterator<T>, forEach: (item: T, index: number, arr: T[]) => (any | Generator<any, any, any>)) {
+  return wrapForEachToGenerator(Array.from(list), forEach);
+}
+
+/**
+ * 数组 forEach 回调包装为生成器
+ *
+ * @description 回调中允许使用生成器
+ */
+export function wrapForEachToGenerator<T>(list: T[], forEach: (item: T, index: number, arr: T[]) => (any | Generator<any, any, any>)) {
+  const len = list.length;
+
+  return (function* transformListToGenerator(): Generator<any, any, any> {
+    for (let i = 0; i < len; i++) {
+      const result = forEach(list[i], i, list);
+
+      if (isGenerator(result)) {
+        yield* result;
+      }
+
+      yield;
+    }
+  })();
+}
+
+/**
+ * 数组 map 回调包装为生成器
+ *
+ * @description 回调中允许使用生成器
+ */
+export function wrapMapToGenerator<T, U>(list: T[], map: (item: T, index: number, arr: T[]) => (U | Generator<any, U, any>)) {
+  const len = list.length;
+  const resultArr: U[] = Array(len);
+
+  return (function* transformListToGenerator(): Generator<any, U[], any> {
+    for (let i = 0; i < len; i++) {
+      const result = map(list[i], i, list);
+
+      if (isGenerator(result)) {
+        resultArr[i] = yield* result;
+      }
+      else {
+        resultArr[i] = result;
+      }
+
+      yield;
+    }
+
+    return resultArr;
+  })();
+}

package/src/utils/types.ts

@@ -1 +1,10 @@
+import type { SourceMap } from '../translator';
+
 export type GetPromise<T> = T extends Promise<infer R> ? R : never;
+export interface EmbeddedTSFileResult {
+  code: string;
+  filePath: string;
+  sourceMap: SourceMap
+}
+
+export type EmbeddedTSFileGenerator = Generator<void, EmbeddedTSFileResult, string>;

package/test/concepts/anonymous-function/toEmbeddedTS.spec.ts

@@ -1,5 +1,6 @@
 import { expect } from 'chai';
 import type { AnonymousFunction } from '../../../out';
+import { runGeneratorSync as runSync } from '../../../out/utils';
 import { readFixture, formatTs, getNodeByData } from '../utils';
 import { ConceptName, cases } from './constant';
 
@@ -8,7 +9,7 @@ describe(`${ConceptName}:toEmbeddedTS`, () => {
     it(name, () => {
       const data = readFixture(ConceptName, name);
       const node = getNodeByData<AnonymousFunction>(data);
-      expect(formatTs(node.toEmbeddedTS())).toMatchSnapshot();
+      expect(formatTs(runSync(node.toEmbeddedTS()))).toMatchSnapshot();
     });
   });
 });