@zk-tech/bedrock 0.0.1 → 0.1.0

package/src/platform/index.ts

@@ -1,64 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-let _isWindows = false;
-let _isMac = false;
-let _isLinux = false;
-let _isWeb = false;
-let _isIOS = false;
-let _isAndroid = false;
-let _isMobile = false;
-let _isIPad = false;
-let _isFirefox = false;
-let _isChrome = false;
-let _isSafari = false;
-let _userAgent: string | undefined;
-
-// Web environment
-if (typeof navigator === 'object') {
-  _userAgent = navigator.userAgent;
-  _isWindows = _userAgent.indexOf('Windows') >= 0;
-  _isIOS =
-    (_userAgent.indexOf('Macintosh') >= 0 ||
-      _userAgent.indexOf('iPad') >= 0 ||
-      _userAgent.indexOf('iPhone') >= 0) &&
-    Boolean(navigator.maxTouchPoints) &&
-    navigator.maxTouchPoints > 0;
-  _isAndroid = _userAgent.indexOf('Android') >= 0;
-  _isLinux = _userAgent.indexOf('Linux') >= 0;
-  _isMobile = _userAgent.indexOf('Mobi') >= 0;
-  _isIPad = _userAgent.indexOf('iPad') >= 0;
-  _isMac = !_isMobile && _userAgent.indexOf('Macintosh') >= 0;
-  _isFirefox = /firefox/i.test(_userAgent);
-  _isChrome = /chrome/i.test(_userAgent);
-  _isSafari = /^((?!chrome|android).)*safari/i.test(_userAgent);
-  _isWeb = true;
-}
-
-export const isWindows = _isWindows;
-export const isMac = _isMac;
-export const isLinux = _isLinux;
-export const isWeb = _isWeb;
-export const isIOS = _isIOS;
-export const isAndroid = _isAndroid;
-export const isIPad = _isIPad;
-export const isMobile = _isMobile;
-export const isChrome = _isChrome;
-export const isFirefox = _isFirefox;
-export const isSafari = _isSafari;
-
-/**
- * 判断是否为 Arc 浏览器
- * arc 浏览器判定方式比较奇特，无法通过 UA 判断
- * https://stackoverflow.com/questions/76123232/can-javascript-detect-the-arc-browser
- */
-export function isArcBrowser(): boolean {
-  return getComputedStyle(document.documentElement).getPropertyValue('--arc-palette-title') ? true : false;
-};
-
-/** ace2.0 不再提供这个方法  用于判断是否为浏览器环境*/
-export function isBrowser(): boolean {
-  return (
-    typeof window !== 'undefined' &&
-    typeof window.document !== 'undefined' &&
-    typeof window.document.createElement !== 'undefined'
-  );
-}

package/src/promise/index.ts

@@ -1,16 +0,0 @@
-// defer相关
-export type { Deferred } from './promise';
-export { defer } from './promise';
-
-// 包装后可dispose的promise能力
-export type { CancelablePromise } from './promise';
-export { makeCancelablePromise } from './promise';
-
-// 并发执行一组promise
-export { parallelPromise } from './promise';
-
-// 让一个promise设置超时时间
-export { makePromiseWithTimeout } from './promise';
-
-// 生成一个等待AbortSignal的promise
-export { waitForAbortSignal } from './promise';

package/src/promise/promise.test.ts

@@ -1,254 +0,0 @@
-/* eslint-disable max-nested-callbacks */
-import type { ILvErrorOr, ILvErrorRef } from '../error';
-import { GenericError, makeError } from '../error';
-import type { ICancellationToken } from '../async';
-import { makeCancelablePromise, makePromiseWithTimeout, parallelPromise } from './promise';
-
-describe('cancel promise', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  // promise可以正常resolve
-  it('promise resolve', async () => {
-    let res: ILvErrorOr<boolean> | undefined;
-    makeCancelablePromise(
-      (_token: ICancellationToken) =>
-        new Promise<boolean>((resolve) => {
-          setTimeout(() => resolve(true), 400);
-        }),
-    ).then((result) => {
-      res = result;
-    });
-    vi.advanceTimersByTime(500);
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(res).not.toBeUndefined();
-    expect(res!.ok).toBeTruthy();
-  });
-
-  // promise可以正常reject
-  it('promise reject', async () => {
-    let res: ILvErrorOr<boolean> | undefined;
-    makeCancelablePromise(
-      (_token: ICancellationToken) =>
-        new Promise<boolean>((resolve, reject) => {
-          setTimeout(() => reject(), 400);
-        }),
-    )
-      .then((result) => {
-        res = result;
-      })
-      .catch(() => {
-        res = makeError(-1, '');
-      });
-    vi.advanceTimersByTime(500);
-    await Promise.resolve();
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(res).not.toBeUndefined();
-    expect(res!.ok).toBeFalsy();
-    expect(res!.code).toBe(-1);
-  });
-
-  // promise可以取消
-  it('cancel success', async () => {
-    let res: ILvErrorOr<boolean> | undefined;
-    const p = makeCancelablePromise(
-      (_token: ICancellationToken) =>
-        new Promise<boolean>((resolve) => {
-          setTimeout(() => resolve(true), 400);
-        }),
-    );
-    p.then((result) => {
-      res = result;
-    });
-    vi.advanceTimersByTime(200);
-    await Promise.resolve();
-    expect(res).toBeUndefined();
-
-    // 中途取消
-    p.cancel();
-
-    // 不用等到resolve，res已经回来了
-    vi.advanceTimersByTime(50);
-    await Promise.resolve();
-    expect(res).not.toBeUndefined();
-
-    // 哪怕等到resolve回来，结果也不会错误
-    vi.advanceTimersByTime(300);
-    await Promise.resolve();
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(res!.ok).toBeFalsy();
-    expect(res!.code).toBe(GenericError.Cancelled);
-  });
-});
-
-describe('parallel promise', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  // 所有的promise都可以正常成功执行
-  it('all promise success', async () => {
-    let t = 0;
-    const p1 = new Promise<number>((resolve, reject) => {
-      resolve(1);
-    }).then((value) => {
-      t += value;
-    });
-    const p2 = makeCancelablePromise(() =>
-      new Promise<number>((resolve, reject) => {
-        setTimeout(() => resolve(2), 500);
-      }).then((value) => {
-        t += value;
-      }),
-    );
-
-    parallelPromise([p1, p2]);
-    vi.advanceTimersByTime(500);
-    await Promise.resolve();
-    expect(t).toBe(3);
-  });
-
-  // 单个promise reject，错误可以抛出，其他promise正常执行
-  it('one promise reject, anthor run', async () => {
-    let t = 0;
-    const p1 = new Promise<number>((resolve, reject) => {
-      reject(new Error('test error.'));
-    }).then((value) => {
-      t += value;
-    });
-    const p2 = new Promise<number>((resolve, reject) => {
-      setTimeout(() => resolve(2), 500);
-    }).then((value) => {
-      t += value;
-    });
-
-    try {
-      await parallelPromise([p1, p2]);
-      expect(true).toBe(false);
-    } catch (err: any) {
-      expect(err.message).toBe('test error.');
-    } finally {
-      // 虽然p1失败了，但是p2还是正常执行了
-      vi.advanceTimersByTime(500);
-      await Promise.resolve();
-      expect(t).toBe(2);
-    }
-  });
-
-  // 单个promise reject，错误可以抛出，其他cancelablePromise尽量取消
-  it('one promise reject, anthor cancel', async () => {
-    let t = 0;
-    const p1 = new Promise<number>((resolve, reject) => {
-      reject(new Error('p1 error.'));
-    }).then((value) => {
-      t += value;
-    });
-    const p2 = makeCancelablePromise(() =>
-      new Promise<number>((resolve, reject) => {
-        setTimeout(() => resolve(2), 500);
-      }).then((value) => {
-        t += value;
-      }),
-    );
-
-    try {
-      await parallelPromise([p1, p2]);
-      expect(true).toBe(false);
-    } catch (err: any) {
-      expect(err.message).toBe('p1 error.');
-    } finally {
-      expect(t).toBe(0);
-    }
-  });
-
-  // 单个promise error，其他cancelablePromise尽量取消
-  it('one promise error, anthor cancel', async () => {
-    let t = 0;
-    const p1 = new Promise<ILvErrorRef>((resolve) => {
-      resolve(makeError(-1, 'p1 error.'));
-    });
-    const p2 = makeCancelablePromise(() =>
-      new Promise<number>((resolve, reject) => {
-        setTimeout(() => resolve(2), 500);
-      }).then((value) => {
-        t += value;
-      }),
-    );
-
-    const result = await parallelPromise([p1, p2]);
-    expect(result.ok).toBeFalsy();
-    expect(result.msg).toBe('p1 error.');
-    // p1失败了，p2被cancel了
-    expect(t).toBe(0);
-  });
-});
-
-describe('promiseWithTimeout', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  // 超时
-  it('test1', async () => {
-    const promise = makePromiseWithTimeout(() => {
-      return new Promise((resolve) => {
-        setTimeout(() => {
-          resolve(233);
-        }, 200);
-      });
-    }, 100);
-    vi.advanceTimersByTime(150);
-    await Promise.resolve();
-    const result = await promise;
-    expect(result.ok).toBeFalsy();
-    expect(result.toString()).toBe('[2]operation(s) timed out..');
-  });
-
-  // 未超时
-  it('test2', async () => {
-    const promise = makePromiseWithTimeout((): Promise<number> => {
-      return new Promise((resolve) => {
-        setTimeout(() => {
-          resolve(233);
-        }, 200);
-      });
-    }, 300);
-    vi.advanceTimersByTime(250);
-    await Promise.resolve();
-    const result = await promise;
-    expect(result.ok).toBeTruthy();
-    if (result.ok) {
-      expect(result.value).toBe(233);
-    } else {
-      expect(true).toBe(false);
-    }
-  });
-
-  // 超时但存在默认值
-  it('test3', async () => {
-    const promise = makePromiseWithTimeout(
-      () => {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            resolve(233);
-          }, 200);
-        });
-      },
-      100,
-      666,
-    );
-    vi.advanceTimersByTime(150);
-    await Promise.resolve();
-    const result = await promise;
-    expect(result.ok).toBeTruthy();
-    if (result.ok) {
-      expect(result.value).toBe(666);
-    } else {
-      expect(true).toBe(false);
-    }
-  });
-});

package/src/promise/promise.ts

@@ -1,212 +0,0 @@
-import {
-  makeOkWith,
-  type ILvErrorOr,
-  cancelledError,
-  GenericError,
-  timeoutError,
-  type ILvErrorRef,
-  makeOk,
-  isLvErrorRef,
-} from '../error';
-import type { ICancellationToken } from '../async';
-import { CancellationTokenSource } from '../async';
-
-/**
- * 一般来说Promise常用的场景有：
- * 1. 单次异步调用（new Promise）
- * 2. 批量promise调用（Promise.all）
- * 3. promise竞速调用（Promise.race）
- *
- * 但是原生能力有如下的缺陷
- * 1. 不支持取消某一次promise调用
- * 2. 不支持错误语义，promise.catch的重视程度比try catch还低
- * 3. 超时行为需要基于race封装
- *
- * 针对这三点，基建侧提供了高阶的promise能力
- * 1. makeCancelablePromise 返回一个可取消的promise
- * const promise = makeCancelablePromise(() => { ... });
- * promise.then((res) => {
- *   // res是一个ILvErrorRef对象
- * });
- * // 可以直接取消promise
- * promise.cancel();
- *
- * 2. parallelPromise 并发执行promise，会自动观测ILvErrorRef语义
- * 当单个promise出现错误返回时，promise执行失败，尽可能调用所有cancelablePromise
- * 当单个promise出现reject时，promise执行失败，尽可能调用所有cancelablePromise，并且将reject继续上抛
- *
- * 3. makePromiseWithTimeout 让promise支持超时，可以提供默认值
- *
- * ——————————————————
- * Promise.allSettled和Promise.any在实际使用中场景较少，暂不提供错误语义包装
- */
-
-//
-// 可以cancel的promise对象
-//
-export interface CancelablePromise<T> extends Promise<T> {
-  cancel: () => void;
-}
-
-/**
- * 快速生成一个CancelablePromise对象
- */
-export function makeCancelablePromise<T>(
-  callback: (token: ICancellationToken) => Promise<T | ILvErrorOr<T>>,
-): CancelablePromise<ILvErrorOr<T>> {
-  const source = new CancellationTokenSource();
-  const thenable = callback(source.token);
-  const promise = new Promise<ILvErrorOr<T>>((resolve, reject) => {
-    const subscription = source.token.onCancellationRequested(() => {
-      subscription.dispose();
-      source.dispose();
-      resolve(cancelledError());
-    });
-    Promise.resolve(thenable).then(
-      (value) => {
-        subscription.dispose();
-        source.dispose();
-        if (isLvErrorRef(value)) {
-          resolve(value);
-        } else {
-          resolve(makeOkWith(value as T));
-        }
-      },
-      (err) => {
-        subscription.dispose();
-        source.dispose();
-        reject(err);
-      },
-    );
-  });
-  return new (class {
-    cancel() {
-      source.cancel();
-    }
-    then<TResult1 = T, TResult2 = never>(
-      resolve?: ((value: ILvErrorOr<T>) => TResult1 | Promise<TResult1>) | undefined | null,
-      reject?: ((reason: any) => TResult2 | Promise<TResult2>) | undefined | null,
-    ): Promise<TResult1 | TResult2> {
-      return promise.then(resolve, reject);
-    }
-    catch<TResult = never>(
-      reject?: ((reason: any) => TResult | Promise<TResult>) | undefined | null,
-    ): Promise<T | TResult> {
-      return this.then(undefined, reject);
-    }
-    finally(onfinally?: (() => void) | undefined | null): Promise<ILvErrorOr<T>> {
-      return promise.finally(onfinally);
-    }
-  })() as CancelablePromise<ILvErrorOr<T>>;
-}
-
-/**
- * 并行执行promise，当某一个失败，本次调用失败
- * 本质上和Promise.all差不多，相比较之下
- * 1. 包装了错误语义判断
- * 2. 当失败时，会尽可能尝试cancel其他promise
- *
- * 注意：某一个promise失败时，会尽可能尝试调用其他promise的cancel，但不保证一定有效
- * （有可能promiseA已经成功，但是primiseB在之后失败了）
- */
-export function parallelPromise(promiseList: Promise<any>[]): Promise<ILvErrorRef> {
-  if (promiseList.length === 0) {
-    return Promise.resolve(makeOk());
-  }
-
-  let todo = promiseList.length;
-  const finish = () => {
-    todo = -1;
-    for (const promise of promiseList) {
-      (promise as Partial<CancelablePromise<any>>).cancel?.();
-    }
-  };
-
-  return new Promise<ILvErrorRef>((resolve, reject) => {
-    for (const promise of promiseList) {
-      promise
-        // eslint-disable-next-line @typescript-eslint/no-loop-func
-        .then((res) => {
-          if (isLvErrorRef(res) && !res.ok) {
-            finish();
-            resolve(res as ILvErrorRef);
-            return;
-          }
-          todo--;
-          if (todo === 0) {
-            resolve(makeOk());
-          }
-        })
-        .catch((err) => {
-          finish();
-          reject(err);
-        });
-    }
-  });
-}
-
-/**
- * 包装一个promise，提供超时能力
- */
-export function makePromiseWithTimeout<T>(
-  callback: (token: ICancellationToken) => Promise<T | ILvErrorOr<T>>,
-  timeout: number,
-  defaultValue?: T, // 当发生超时时，提供的默认值
-): Promise<ILvErrorOr<T>> {
-  const cancellable = makeCancelablePromise<T>(callback);
-  const timer = setTimeout(() => {
-    cancellable.cancel();
-  }, timeout);
-  return cancellable.then((res: ILvErrorOr<T>) => {
-    clearTimeout(timer);
-    if (res.ok) {
-      return res;
-    }
-    // 如果是被取消，触发了超时
-    if (res.code === GenericError.Cancelled) {
-      if (defaultValue !== undefined) {
-        // 希望返回默认值
-        return makeOkWith(defaultValue);
-      }
-      return timeoutError();
-    } else {
-      // 遇到其他错误时透传错误
-      return res;
-    }
-  });
-}
-
-// 如果 proposal-promise-with-resolvers 通过了，那么这个函数就可以去掉了
-// https://github.com/microsoft/TypeScript/blob/1d96eb489e559f4f61522edb3c8b5987bbe948af/src/harness/util.ts#L115
-export interface Deferred<T> {
-  resolve: (value: T | PromiseLike<T>) => void;
-  reject: (reason?: unknown) => void;
-  promise: Promise<T>;
-}
-
-export function defer<T = void>(): Deferred<T> {
-  let resolve!: (value: T | PromiseLike<T>) => void;
-  let reject!: (reason?: unknown) => void;
-  const promise = new Promise<T>((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  return { resolve, reject, promise };
-}
-
-export function waitForAbortSignal(signal: AbortSignal) {
-  const { promise, reject } = defer<never>();
-
-  if (signal.aborted) {
-    reject(signal.reason);
-  }
-
-  const handleAbort = () => {
-    reject(signal.reason);
-    signal.removeEventListener('abort', handleAbort);
-  };
-
-  signal.addEventListener('abort', handleAbort);
-
-  return promise;
-}

package/src/scheduler/callback-token.ts

@@ -1,31 +0,0 @@
-import type { IDisposable } from '../dispose';
-import { Task } from './core/task';
-import { getTimeout, makeTask } from './core/utils';
-import { getScheduler } from './core/scheduler';
-import type { PriorityLevel } from './type';
-
-export class CallbackToken implements IDisposable {
-  constructor(private _task: Task) {}
-
-  dispose() {
-    this._task.clearCallback();
-  }
-
-  updatePriorityLevel(priorityLevel: PriorityLevel) {
-    const callback = this._task.getCallback();
-    if (!callback) {
-      return;
-    }
-    this._task.clearCallback();
-    const newTask = makeTask(callback, {
-      priorityLevel,
-    });
-    const startTime = this._task.getStartTime();
-    const timeout = getTimeout(priorityLevel);
-    const expirationTime = startTime + timeout;
-    newTask.setStartTime(startTime);
-    newTask.setExpirationTime(expirationTime);
-    getScheduler().addTask(newTask);
-    this._task = newTask;
-  }
-}

package/src/scheduler/core/actuator-args.test.ts

@@ -1,47 +0,0 @@
-import { Actuator } from './actuator';
-import { getScheduler } from './scheduler';
-import { Task } from './task';
-import { getCurrentTime } from './utils';
-
-const scheduler = getScheduler();
-
-describe('Callback Arguments', () => {
-  let skipYieldCount: number = 0;
-  beforeAll(() => {
-    // mock该方法，否则不方便测试
-    scheduler.shouldYieldToHost = vi.fn(() => {
-      if (skipYieldCount > 0) {
-        skipYieldCount--;
-        return false;
-      }
-      return true;
-    });
-  });
-
-  beforeEach(() => {
-    scheduler.taskQueue.waitingTasks.clear();
-    scheduler.taskQueue.timerTasks.clear();
-
-    vi.useFakeTimers();
-  });
-
-  // 已经超出过期时间
-  // didUserCallbackTimeout返回true
-  // remainingTime返回10
-  test('arguments1', async () => {
-    skipYieldCount = 1;
-    const fn = vi.fn();
-    let currentTime = getCurrentTime();
-    const task = new Task(fn, currentTime, currentTime + 10);
-    scheduler.taskQueue.timerTasks.insert(task);
-    const actuator = new Actuator(scheduler.taskQueue, scheduler);
-    vi.advanceTimersByTime(10);
-    await Promise.resolve();
-
-    currentTime = getCurrentTime();
-    expect(actuator.workLoop(true, currentTime, currentTime + 16)).toBeFalsy();
-    expect(fn).toBeCalled();
-    expect(fn.mock.calls[0][1]).toBeTruthy();
-    expect(fn.mock.calls[0][2]).toBe(16);
-  });
-});

package/src/scheduler/core/actuator.test.ts

@@ -1,82 +0,0 @@
-import { Actuator } from './actuator';
-import { getScheduler } from './scheduler';
-import { Task } from './task';
-import { getCurrentTime } from './utils';
-
-const scheduler = getScheduler();
-
-describe('Actuator', () => {
-  let skipYieldCount: number = 0;
-  beforeAll(() => {
-    // mock该方法，否则不方便测试
-    scheduler.shouldYieldToHost = vi.fn(() => {
-      if (skipYieldCount > 0) {
-        skipYieldCount--;
-        return false;
-      }
-      return true;
-    });
-  });
-
-  beforeEach(() => {
-    scheduler.taskQueue.waitingTasks.clear();
-    scheduler.taskQueue.timerTasks.clear();
-  });
-
-  // 等待队列为空
-  test('workLoop1', () => {
-    skipYieldCount = 1;
-    const actuator = new Actuator(scheduler.taskQueue, scheduler);
-    expect(actuator.workLoop(true, 0, 5)).toBeFalsy();
-  });
-
-  // 等待队列有内容
-  test('workLoop2', () => {
-    skipYieldCount = 1;
-    const fn = vi.fn();
-    const task = new Task(fn, 0, getCurrentTime() + 1000);
-    scheduler.taskQueue.waitingTasks.insert(task);
-    const actuator = new Actuator(scheduler.taskQueue, scheduler);
-
-    expect(actuator.workLoop(true, 0, 5)).toBeFalsy();
-    expect(fn).toBeCalled();
-  });
-
-  // 等待队列有内容，执行后还有内容
-  test('workLoop3', () => {
-    skipYieldCount = 1;
-    const fn = vi.fn();
-    const task1 = new Task(fn, 0, getCurrentTime() + 1000);
-    const task2 = new Task(fn, 0, getCurrentTime() + 1000);
-    scheduler.taskQueue.waitingTasks.insert(task1);
-    scheduler.taskQueue.waitingTasks.insert(task2);
-    const actuator = new Actuator(scheduler.taskQueue, scheduler);
-
-    expect(actuator.workLoop(true, 0, 5)).toBeTruthy();
-    expect(fn).toBeCalledTimes(1);
-  });
-
-  // 延时队列有内容，需要执行
-  test('workLoop4', () => {
-    skipYieldCount = 1;
-    const fn = vi.fn();
-    const task = new Task(fn, 0, getCurrentTime() + 1000);
-    scheduler.taskQueue.timerTasks.insert(task);
-    const actuator = new Actuator(scheduler.taskQueue, scheduler);
-
-    expect(actuator.workLoop(true, 0, 5)).toBeFalsy();
-    expect(fn).toBeCalled();
-  });
-
-  // 延时队列有内容，暂时无需执行
-  test('workLoop5', () => {
-    skipYieldCount = 1;
-    const fn = vi.fn();
-    const task = new Task(fn, 10, getCurrentTime() + 1000);
-    scheduler.taskQueue.timerTasks.insert(task);
-    const actuator = new Actuator(scheduler.taskQueue, scheduler);
-
-    expect(actuator.workLoop(true, 0, 5)).toBeFalsy();
-    expect(fn).not.toBeCalled();
-  });
-});