rockbed 0.1.0

package/dist/lock/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/assert/assert.ts","../../src/dispose/disposable-t.ts","../../src/dispose/disposable-utils.ts","../../src/event/emitter.ts","../../src/lock/capability.ts","../../src/lock/semaphore.ts","../../src/lock/shared-mutex.ts"],"sourcesContent":["function abort(reason: string): never {\n  throw new Error(`lvAssert(${reason})`);\n}\n\nexport function lvAssert(expr: unknown, reason?: string): asserts expr {\n  if (!expr) {\n    abort(reason ?? '#expr is false');\n  }\n}\n\nexport function lvAssertNotHere(reason?: string): never {\n  abort(reason ?? 'unreachable code flow');\n}\n\nexport function lvAssertNever(member: never, message = 'Illegal value:'): never {\n  // eslint-disable-next-line @typescript-eslint/restrict-template-expressions\n  abort(`${message}: ${member}`);\n}\n\nexport function lvAssertNotNil<T>(val: T, reason?: string): asserts val is NonNullable<T> {\n  if (val === null || val === undefined) {\n    abort(reason ?? '#val is nil');\n  }\n}\n","import { DisposableStore } from './disposable-store';\nimport type { IDisposable } from './dispose-base';\nimport { BRANCH_DISPOSE } from './logger';\n\n//\n// Disposable基类\n//\n// 自动添加DisposableStore，提供默认的dispose和register方法\n//\nexport abstract class Disposable implements IDisposable {\n  protected readonly _store = new DisposableStore();\n\n  // 销毁该节点和所有的子节点\n  dispose(): void {\n    BRANCH_DISPOSE(this.constructor.name, this._store.constructor.name);\n\n    this._store.dispose();\n  }\n\n  // 挂载子节点\n  protected _register<T extends IDisposable>(o: T): T {\n    if ((o as unknown as Disposable) === this) {\n      throw new Error('Cannot register a disposable on itself!');\n    }\n    return this._store.add(o);\n  }\n}\n\nexport class MutableDisposable<T extends IDisposable> implements IDisposable {\n  private _value?: T;\n  private _isDisposed = false;\n\n  constructor(value?: T) {\n    this.value = value;\n  }\n\n  get value(): T | undefined {\n    return this._isDisposed ? undefined : this._value;\n  }\n\n  set value(value: T | undefined) {\n    if (this._isDisposed || value === this._value) {\n      return;\n    }\n\n    this._value?.dispose();\n    this._value = value;\n  }\n\n  clear(): void {\n    this.value = undefined;\n  }\n\n  dispose(): void {\n    this._isDisposed = true;\n    this._value?.dispose();\n    this._value = undefined;\n  }\n\n  release(): T | undefined {\n    const oldValue = this._value;\n    this._value = undefined;\n    return oldValue;\n  }\n}\n\nexport class SafeDisposable<T extends IDisposable> implements IDisposable {\n  private _value: T | null = null;\n\n  constructor(value: T) {\n    this._value = value;\n  }\n\n  isEmpty() {\n    return this._value === null;\n  }\n\n  dispose() {\n    if (!this._value) {\n      return;\n    }\n    this._value.dispose();\n    this._value = null;\n  }\n}\n","import { SafeDisposable } from './disposable-t';\nimport { EmptyDispose } from './dispose-base';\n\nexport function makeSafeDisposable(fn: (...args: any) => any) {\n  const disposable = new SafeDisposable({\n    dispose: fn,\n  });\n  return disposable;\n}\n\nexport function makeEmptyDisposable() {\n  return EmptyDispose;\n}\n","/* eslint-disable @typescript-eslint/no-redundant-type-constituents */\nimport { makeSafeDisposable } from '../dispose';\nimport type { IDisposable } from '../dispose';\n\nexport interface EmitterOptions {\n  onAddListener?: (...args: any) => any;\n  onRemoveListener?: (...args: any) => any;\n  onListenerError?: (e: any) => void;\n}\n\n/**\n * 默认错误处理：异步抛出监听器错误，避免阻塞当前事件分发。\n */\nexport function asyncUnexpectedErrorHandler(e: unknown): undefined {\n  setTimeout(() => {\n    throw e;\n  }, 0);\n}\n\n/**\n * 同步抛出监听器错误，适合测试或需要立即失败的场景。\n */\nexport function syncUnexpectedError(e: unknown): undefined {\n  throw e;\n}\n\n/**\n * 忽略监听器错误，适合明确允许 best-effort 通知的场景。\n */\nexport function ignoreUnexpectedError(_e: unknown): undefined {}\n\n//\n// 事件监听中的回调实体\n//\nclass Listener<TArgs extends any[]> {\n  private readonly _callback: (...args: TArgs) => void;\n  private readonly _callbackThis: any | undefined;\n\n  constructor(callback: (...args: TArgs) => void, callbackThis: any | undefined) {\n    this._callback = callback;\n    this._callbackThis = callbackThis;\n  }\n\n  invoke(...args: TArgs): void {\n    this._callback.call(this._callbackThis, ...args);\n  }\n}\n\n//\n// 存放在EventDeliveryQueue中的元素\n//\nclass EventDeliveryQueueElement<TArgs extends any[]> {\n  readonly emitter: Emitter<TArgs>;\n  readonly listener: Listener<TArgs>;\n  readonly event: TArgs;\n  constructor(emitter: Emitter<TArgs>, listener: Listener<TArgs>, event: TArgs) {\n    this.emitter = emitter;\n    this.listener = listener;\n    this.event = event;\n  }\n}\n\nexport class EventDeliveryQueue {\n  protected _queue: EventDeliveryQueueElement<any>[] = [];\n\n  constructor(\n    private readonly _onListenerError: (e: unknown) => void = asyncUnexpectedErrorHandler,\n  ) {}\n\n  get size(): number {\n    return this._queue.length;\n  }\n\n  push<TArgs extends any[]>(\n    emitter: Emitter<TArgs>,\n    listener: Listener<TArgs>,\n    event: TArgs,\n  ): void {\n    this._queue.push(new EventDeliveryQueueElement(emitter, listener, event));\n  }\n\n  clear<TArgs extends any[]>(emitter: Emitter<TArgs>): void {\n    this._queue = this._queue.filter((element) => element.emitter !== emitter);\n  }\n\n  deliver(): void {\n    while (this._queue.length > 0) {\n      const element = this._queue.shift()!;\n      try {\n        element.listener.invoke(...element.event);\n      } catch (e) {\n        this._onListenerError(e);\n      }\n    }\n  }\n}\n\nexport interface Event<T extends any[]> {\n  (listener: (...args: T) => any, thisArgs?: any): IDisposable;\n}\n\nexport class Emitter<TArgs extends any[]> {\n  protected _listeners?: Set<Listener<TArgs>>;\n  private readonly _options?: EmitterOptions;\n  private _disposed = false;\n  private _event?: Event<TArgs>;\n  private _deliveryQueue?: EventDeliveryQueue;\n\n  constructor(options?: EmitterOptions) {\n    this._options = options;\n  }\n\n  get event(): Event<TArgs> {\n    if (this._event) {\n      return this._event;\n    }\n\n    this._event = (callback: (...args: TArgs) => any, thisArgs?: any): IDisposable => {\n      if (!this._listeners) {\n        this._listeners = new Set();\n      }\n\n      const listener = new Listener(callback, thisArgs);\n      this._listeners.add(listener);\n\n      if (this._options?.onAddListener) {\n        this._options.onAddListener(this, callback, thisArgs);\n      }\n\n      // 生成可销毁函数返回\n      const result = () => {\n        if (!this._disposed) {\n          this._listeners?.delete(listener);\n          if (this._options?.onRemoveListener) {\n            this._options.onRemoveListener(this, callback, thisArgs);\n          }\n        }\n      };\n\n      return makeSafeDisposable(result);\n    };\n\n    return this._event;\n  }\n\n  dispose(): void {\n    if (this._disposed) {\n      return;\n    }\n    this._disposed = true;\n    this._listeners?.clear();\n    this._deliveryQueue?.clear(this);\n  }\n\n  fire(...event: TArgs): void {\n    if (!this._listeners) {\n      return;\n    }\n    this._deliveryQueue ??= new EventDeliveryQueue(this._options?.onListenerError);\n\n    for (const listener of this._listeners) {\n      this._deliveryQueue.push(this, listener, event);\n    }\n    this._deliveryQueue.deliver();\n  }\n}\n\n// 辅助能力：只监听某个事件一次\nexport function listenOnce<TArgs extends any[]>(event: Event<TArgs>): Event<TArgs> {\n  return (listener, thisArgs = null) => {\n    let didFire = false;\n    let result: IDisposable | undefined = undefined;\n\n    result = event((...args) => {\n      if (didFire) {\n        return;\n      }\n      if (result) {\n        result.dispose();\n      } else {\n        didFire = true;\n      }\n\n      return listener.call(thisArgs, ...args);\n    }, null);\n\n    if (didFire) {\n      result.dispose();\n    }\n\n    return result;\n  };\n}\n","import { lvAssert } from '../assert';\nimport { Emitter, type Event } from '../event';\n\n//\n// 资源对应的是标准库中的 unsigned state 以及相关的位运算\n// 我们用两个具体的Capability结构实现（Capability命名来源于标准库）\n//\n\n/**\n * 资源状态\n */\nexport enum CapabilityStatus {\n  Unlocked,\n  Locked,\n}\n\n/**\n * 独享的资源\n *\n * acquire 获取控制权\n * release 释放控制权\n */\nexport class Capability {\n  public onUnlocked: Event<[]>;\n\n  private readonly _onUnlocked = new Emitter<[]>();\n  private _status = CapabilityStatus.Unlocked;\n\n  constructor() {\n    this.onUnlocked = this._onUnlocked.event;\n  }\n\n  get status(): CapabilityStatus {\n    return this._status;\n  }\n\n  public acquire(): void {\n    lvAssert(this._status === CapabilityStatus.Unlocked);\n    this._status = CapabilityStatus.Locked;\n  }\n\n  public release(): void {\n    lvAssert(this._status === CapabilityStatus.Locked);\n    this._status = CapabilityStatus.Unlocked;\n    this._onUnlocked.fire();\n  }\n}\n\n/**\n * 共享的资源\n *\n * acquire 获取控制权\n * release 释放控制权\n */\nexport class SharedCapability {\n  public onUnlocked: Event<[]>;\n\n  private readonly _onUnlocked = new Emitter<[]>();\n  private _status = CapabilityStatus.Unlocked;\n  private _counter = 0;\n\n  constructor() {\n    this.onUnlocked = this._onUnlocked.event;\n  }\n\n  get status(): CapabilityStatus {\n    return this._status;\n  }\n\n  get counter(): number {\n    return this._counter;\n  }\n\n  public acquire() {\n    if (this._status === CapabilityStatus.Unlocked) {\n      this._status = CapabilityStatus.Locked;\n    }\n    this._counter++;\n  }\n\n  public release() {\n    lvAssert(this._counter > 0);\n    this._counter--;\n    if (this._counter === 0) {\n      this._status = CapabilityStatus.Unlocked;\n      this._onUnlocked.fire();\n    }\n  }\n}\n","import type { Event } from '../event';\nimport { Emitter } from '../event';\n\n/**\n * 信号\n *\n * 用来模拟标准库的condition_variable\n * 提供监听某个信号被激活的能力\n */\nexport class Semaphore {\n  public onActive: Event<[]>;\n  private readonly _onActive = new Emitter<[]>();\n\n  constructor() {\n    this.onActive = this._onActive.event;\n  }\n\n  public notify(): void {\n    this._onActive.fire();\n  }\n}\n","import { lvAssert, lvAssertNotNil } from '../assert';\nimport { listenOnce } from '../event';\nimport { SharedCapability, Capability, CapabilityStatus } from './capability';\nimport { Semaphore } from './semaphore';\n\n/**\n * 提供读写能力的共享互斥量\n *\n * 参考C++17标准库双门思想实现\n * 接口也与标准库保持一致\n * 方法内部禁止promise，只可以对外暴露promise\n *\n * 核心\n * - 写写互斥，读写互斥，读读可重入\n *\n * 使用举例：\n * class Foo {\n *   private _mutex = new SharedMutex();\n *\n *   async add() {\n *     // 上写锁\n *     await this._mutex.lock();\n *     // ...write something\n *     this._mutex.unlock();\n *   }\n *\n *   async getSomething1() {\n *     // 上读锁\n *     await this._mutex.lockShared();\n *     try {\n *       return xxx;\n *     } finally {\n *       this._mutex.unlockShared();\n *     }\n *   }\n *\n *   async getSomething2() {\n *     // 上读锁\n *     await this._mutex.lockShared();\n *     try {\n *       return xxx;\n *     } finally {\n *       this._mutex.unlockShared();\n *     }\n *   }\n * }\n */\nexport class SharedMutex {\n  // 在第一道门外等待的写者\n  private readonly _waitingWriters: Semaphore[] = [];\n\n  // 已经通过了第一道门的写者\n  // 如果在第二道门外等待，状态为sharedLocked\n  // 如果已经进入到第二道门内拿到了锁，状态为locked\n  private _writer?: Capability;\n\n  // 在第一道门外等待的读者\n  private _waitingReader?: Semaphore;\n\n  // 拿到锁的读者\n  private _reader?: SharedCapability;\n\n  /**\n   * 是否被锁住\n   */\n  public isLocked(): boolean {\n    return Boolean(this._writer) || this._readerCount !== 0;\n  }\n\n  /**\n   * 等待并获取写锁\n   */\n  public lock(): Promise<void> {\n    return new Promise<void>((resolve) => {\n      // 第一道门\n      if (this._writer) {\n        // 如果已经有写者进入了，其他写者等待\n        const token = new Semaphore();\n        this._waitingWriters.push(token);\n        token.onActive(() => {\n          this._writerEnterGate1(resolve);\n        });\n      } else {\n        this._writerEnterGate1(resolve);\n      }\n    });\n  }\n\n  /**\n   * 尝试获取写锁，立刻返回结果\n   */\n  public tryLock(): boolean {\n    if (this._writer || this._readerCount > 0) {\n      return false;\n    }\n    // 这里不需要await，一定可以上锁\n    this.lock();\n    return true;\n  }\n\n  /**\n   * 解除写锁\n   */\n  public unLock(): void {\n    lvAssertNotNil(this._writer);\n\n    // 打开第一道门\n    this._writer.release();\n  }\n\n  /**\n   * 解除写锁。`unLock` 的常规拼写别名。\n   */\n  public unlock(): void {\n    this.unLock();\n  }\n\n  /**\n   * 等待并获取读锁\n   */\n  public lockShared(): Promise<void> {\n    return new Promise<void>((resolve) => {\n      // 读者只需要进第一道门\n      if (this._writer) {\n        // 如果有写者已经进入了第一道门，读者等待\n        if (!this._waitingReader) {\n          this._waitingReader = new Semaphore();\n        }\n        this._waitingReader.onActive(() => {\n          this._readerEnterGate1(resolve);\n        });\n      } else {\n        this._readerEnterGate1(resolve);\n      }\n    });\n  }\n\n  /**\n   * 尝试获取读锁，立刻返回结果\n   */\n  public tryLockShared(): boolean {\n    if (this._writer) {\n      return false;\n    }\n    // 不需要await，一定可以上锁\n    this.lockShared();\n    return true;\n  }\n\n  /**\n   * 解除读锁\n   */\n  public unLockShared(): void {\n    lvAssertNotNil(this._reader);\n    if (this._writer) {\n      // TODO(niurouwan): 暂时保留，方便验证，稳定后可以去掉\n      lvAssert(this._writer.status === CapabilityStatus.Unlocked);\n    }\n\n    this._reader.release();\n  }\n\n  /**\n   * 解除读锁。`unLockShared` 的常规拼写别名。\n   */\n  public unlockShared(): void {\n    this.unLockShared();\n  }\n\n  /**\n   * 获取当前读者数量\n   */\n  private get _readerCount(): number {\n    return this._reader ? this._reader.counter : 0;\n  }\n\n  /**\n   * 写者进入第一道门\n   */\n  private _writerEnterGate1(resolve: () => void): void {\n    lvAssert(!this._writer);\n    // 确定写者，关第一道门\n    this._writer = new Capability();\n\n    // 第二道门\n    // 等待所有读者出去\n    if (this._readerCount > 0) {\n      listenOnce(this._reader!.onUnlocked)(() => {\n        this._writerEnterGate2(resolve);\n      });\n    } else {\n      this._writerEnterGate2(resolve);\n    }\n  }\n\n  /**\n   * 写者进入第二道门\n   */\n  private _writerEnterGate2(resolve: () => void): void {\n    lvAssertNotNil(this._writer);\n    lvAssert(this._readerCount === 0);\n\n    // 成功加锁\n    this._writer.acquire();\n    listenOnce(this._writer.onUnlocked)(() => {\n      lvAssertNotNil(this._writer);\n      // 不再持有\n      this._writer = undefined;\n      this._moveForward();\n    });\n    resolve();\n  }\n\n  /**\n   * 读者进入第一道门\n   */\n  private _readerEnterGate1(resolve: () => void): void {\n    lvAssert(!this._writer);\n\n    // 门外等待的读者清除\n    this._waitingReader = undefined;\n\n    if (!this._reader) {\n      this._reader = new SharedCapability();\n      this._reader.acquire();\n      listenOnce(this._reader.onUnlocked)(() => {\n        this._moveForward();\n      });\n    } else {\n      this._reader.acquire();\n    }\n    resolve();\n  }\n\n  /**\n   * 锁释放时推进流程\n   */\n  private _moveForward(): void {\n    // 如果有写者在等待在第二道门前面，那么此时推进的一定是读锁释放，直接return即可\n    if (this._writer) {\n      return;\n    }\n\n    // 写者优先，优先通知在第一道门前面的写者\n    if (this._waitingWriters.length > 0) {\n      const semaphore = this._waitingWriters.shift()!;\n      semaphore.notify();\n      return;\n    }\n\n    // 最后通知第一道门前面的读者\n    if (this._waitingReader) {\n      this._waitingReader.notify();\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/response/index.d.ts

@@ -0,0 +1,17 @@
+interface ISuccessResponse<T = any> {
+    code: 0;
+    data: T;
+    msg: string;
+}
+interface IErrorResponse {
+    code: Exclude<number, 0>;
+    msg: string;
+}
+type IResponse<T = any> = ISuccessResponse<T> | IErrorResponse;
+declare function makeSuccessResponse<T = any>(data: T): ISuccessResponse<T>;
+declare function makeErrorResponse(code: number, msg: string): {
+    code: number;
+    msg: string;
+};
+
+export { type IErrorResponse, type IResponse, type ISuccessResponse, makeErrorResponse, makeSuccessResponse };

package/dist/response/index.js

@@ -0,0 +1,19 @@
+// src/response/response.ts
+function makeSuccessResponse(data) {
+  return {
+    code: 0,
+    data,
+    msg: "success"
+  };
+}
+function makeErrorResponse(code, msg) {
+  return {
+    code,
+    msg
+  };
+}
+export {
+  makeErrorResponse,
+  makeSuccessResponse
+};
+//# sourceMappingURL=index.js.map

package/dist/response/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/response/response.ts"],"sourcesContent":["export interface ISuccessResponse<T = any> {\n  code: 0;\n  data: T;\n  msg: string;\n}\n\nexport interface IErrorResponse {\n  code: Exclude<number, 0>;\n  msg: string;\n}\n\nexport type IResponse<T = any> = ISuccessResponse<T> | IErrorResponse;\n\nexport function makeSuccessResponse<T = any>(data: T): ISuccessResponse<T> {\n  return {\n    code: 0,\n    data,\n    msg: 'success',\n  };\n}\n\nexport function makeErrorResponse(code: number, msg: string) {\n  return {\n    code,\n    msg,\n  };\n}\n"],"mappings":";AAaO,SAAS,oBAA6B,MAA8B;AACzE,SAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA,KAAK;AAAA,EACP;AACF;AAEO,SAAS,kBAAkB,MAAc,KAAa;AAC3D,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "rockbed",
+  "version": "0.1.0",
+  "description": "Small TypeScript primitives for errors, events, disposables, async helpers, locks, JSON, assertions, and responses.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./assert": {
+      "types": "./dist/assert/index.d.ts",
+      "import": "./dist/assert/index.js"
+    },
+    "./async": {
+      "types": "./dist/async/index.d.ts",
+      "import": "./dist/async/index.js"
+    },
+    "./dispose": {
+      "types": "./dist/dispose/index.d.ts",
+      "import": "./dist/dispose/index.js"
+    },
+    "./error": {
+      "types": "./dist/error/index.d.ts",
+      "import": "./dist/error/index.js"
+    },
+    "./event": {
+      "types": "./dist/event/index.d.ts",
+      "import": "./dist/event/index.js"
+    },
+    "./json": {
+      "types": "./dist/json/index.d.ts",
+      "import": "./dist/json/index.js"
+    },
+    "./lock": {
+      "types": "./dist/lock/index.d.ts",
+      "import": "./dist/lock/index.js"
+    },
+    "./response": {
+      "types": "./dist/response/index.d.ts",
+      "import": "./dist/response/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "tsconfig.json"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "prepack": "npm run clean && npm run typecheck && npm run build"
+  },
+  "keywords": [
+    "typescript",
+    "error-result",
+    "event-emitter",
+    "disposable",
+    "async",
+    "lock"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.0"
+  },
+  "overrides": {
+    "esbuild": "^0.28.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/assert/assert.ts

@@ -0,0 +1,24 @@
+function abort(reason: string): never {
+  throw new Error(`lvAssert(${reason})`);
+}
+
+export function lvAssert(expr: unknown, reason?: string): asserts expr {
+  if (!expr) {
+    abort(reason ?? '#expr is false');
+  }
+}
+
+export function lvAssertNotHere(reason?: string): never {
+  abort(reason ?? 'unreachable code flow');
+}
+
+export function lvAssertNever(member: never, message = 'Illegal value:'): never {
+  // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+  abort(`${message}: ${member}`);
+}
+
+export function lvAssertNotNil<T>(val: T, reason?: string): asserts val is NonNullable<T> {
+  if (val === null || val === undefined) {
+    abort(reason ?? '#val is nil');
+  }
+}

package/src/assert/index.ts

@@ -0,0 +1,2 @@
+// 提供断言能力
+export { lvAssert, lvAssertNotHere, lvAssertNever, lvAssertNotNil } from './assert';

package/src/async/barrier.ts

@@ -0,0 +1,47 @@
+export interface IBarrier {
+  isOpen: () => boolean;
+  open: () => void;
+  wait: () => Promise<boolean>;
+}
+
+/**
+ * A barrier that is initially closed and then becomes opened permanently after a certain period of
+ * time or when open is called explicitly
+ */
+export class Barrier {
+  private _isOpen: boolean;
+  private readonly _promise: Promise<boolean>;
+  private _completePromise!: (v: boolean) => void;
+
+  constructor() {
+    this._isOpen = false;
+    this._promise = new Promise<boolean>((c, e) => {
+      this._completePromise = c;
+    });
+  }
+
+  isOpen(): boolean {
+    return this._isOpen;
+  }
+
+  open(): void {
+    this._isOpen = true;
+    this._completePromise(true);
+  }
+
+  wait(): Promise<boolean> {
+    return this._promise;
+  }
+}
+
+export function makeBarrierByPromise(promise: Promise<any>, openWhenReject: boolean = false) {
+  const barrier = new Barrier();
+  promise.then(() => barrier.open());
+  if (openWhenReject) {
+    promise.catch((err) => {
+      barrier.open();
+      throw err;
+    });
+  }
+  return barrier;
+}

package/src/async/index.ts

@@ -0,0 +1,8 @@
+// 包装后可dispose的promise能力
+export * from './promise';
+
+// 通用的wait函数，提供异步等待能力
+export { wait } from './wait';
+
+// 提供调用 open 后 resolve promise 的能力
+export * from './barrier';

package/src/async/promise.ts

@@ -0,0 +1,316 @@
+/* eslint-disable @typescript-eslint/prefer-promise-reject-errors */
+import {
+  makeOkWith,
+  type ILvErrorOr,
+  cancelledError,
+  GenericError,
+  timeoutError,
+  type ILvErrorRef,
+  makeOk,
+  isLvErrorRef,
+} from '../error';
+import { EmptyDispose, makeSafeDisposable, type IDisposable } from '../dispose';
+
+export interface ICancellationToken {
+  readonly isCancellationRequested: boolean;
+  readonly reason?: string;
+  readonly onCancellationRequested: (
+    listener: () => any,
+    thisArgs?: any,
+  ) => IDisposable;
+}
+
+const shortcutCancellationEvent = (callback: () => any, context?: any): IDisposable => {
+  const handle = setTimeout(callback.bind(context), 0);
+  return makeSafeDisposable(() => clearTimeout(handle));
+};
+
+class MutableToken implements ICancellationToken, IDisposable {
+  private _isCancelled = false;
+  private _reason?: string;
+  private readonly _listeners = new Set<() => void>();
+
+  get isCancellationRequested(): boolean {
+    return this._isCancelled;
+  }
+
+  get reason(): string | undefined {
+    return this._reason;
+  }
+
+  onCancellationRequested(listener: () => any, thisArgs?: any): IDisposable {
+    if (this._isCancelled) {
+      return shortcutCancellationEvent(listener, thisArgs);
+    }
+
+    const wrappedListener = listener.bind(thisArgs);
+    this._listeners.add(wrappedListener);
+    return makeSafeDisposable(() => {
+      this._listeners.delete(wrappedListener);
+    });
+  }
+
+  cancel(reason?: string): void {
+    if (this._isCancelled) {
+      return;
+    }
+
+    this._reason = reason;
+    this._isCancelled = true;
+    for (const listener of this._listeners) {
+      listener();
+    }
+    this._listeners.clear();
+  }
+
+  dispose(): void {
+    this._listeners.clear();
+  }
+}
+
+export class CancellationToken {
+  static None = Object.freeze<ICancellationToken>({
+    isCancellationRequested: false,
+    onCancellationRequested: () => EmptyDispose,
+  });
+
+  static Cancelled = Object.freeze<ICancellationToken>({
+    isCancellationRequested: true,
+    onCancellationRequested: shortcutCancellationEvent,
+  });
+
+  static Make(reason: string): ICancellationToken {
+    return Object.freeze<ICancellationToken>({
+      isCancellationRequested: true,
+      onCancellationRequested: shortcutCancellationEvent,
+      reason,
+    });
+  }
+}
+
+export class CancellationTokenSource implements IDisposable {
+  private _token?: ICancellationToken;
+  private _abortController?: AbortController;
+
+  get token(): ICancellationToken {
+    if (!this._token) {
+      this._token = new MutableToken();
+    }
+    return this._token;
+  }
+
+  get signal(): AbortSignal {
+    if (!this._abortController) {
+      this._abortController = new AbortController();
+    }
+    if (this._token?.isCancellationRequested) {
+      this._abortController.abort(this._token.reason);
+    }
+    return this._abortController.signal;
+  }
+
+  cancel(reason?: string): void {
+    if (!this._token) {
+      this._token =
+        reason === undefined ? CancellationToken.Cancelled : CancellationToken.Make(reason);
+    } else if (this._token instanceof MutableToken) {
+      this._token.cancel(reason);
+    }
+    this._abortController?.abort(reason);
+  }
+
+  dispose(cancel = false): void {
+    if (cancel) {
+      this.cancel();
+    }
+    if (!this._token) {
+      this._token = CancellationToken.None;
+    } else if (this._token instanceof MutableToken) {
+      this._token.dispose();
+    }
+  }
+}
+
+/**
+ * 一般来说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>) | null,
+      reject?: ((reason: any) => TResult2 | Promise<TResult2>) | null,
+    ): Promise<TResult1 | TResult2> {
+      return promise.then(resolve, reject);
+    }
+    catch<TResult = never>(
+      reject?: ((reason: any) => TResult | Promise<TResult>) | null,
+    ): Promise<T | TResult> {
+      return this.then(undefined, reject);
+    }
+    finally(onfinally?: (() => void) | 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
+
+        .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;
+    }
+    // 如果是被取消，触发了超时
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+    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 };
+}

package/src/async/wait.ts

@@ -0,0 +1,7 @@
+/**
+ * 等待一段时间
+ * @param ms 单位毫秒
+ */
+export function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/dispose/disposable-store.ts

@@ -0,0 +1,68 @@
+import type { IDisposable } from './dispose-base';
+import { BRANCH_DISPOSE } from './logger';
+
+export class DisposableStore implements IDisposable {
+  static DISABLE_DISPOSED_WARNING = false;
+
+  private readonly _toDispose = new Set<IDisposable>();
+  private _isDisposed = false;
+
+  get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
+  dispose(): void {
+    if (this._isDisposed) {
+      // 不应该出现重复dispose
+      /* eslint-disable no-console */
+      console.warn(new Error('DisposableStore has disposed.').stack);
+      return;
+    }
+
+    this._isDisposed = true;
+    this.clear();
+  }
+
+  clear(): void {
+    if (this._toDispose.size === 0) {
+      return;
+    }
+
+    for (const disposable of this._toDispose) {
+      BRANCH_DISPOSE(this.constructor.name, disposable.constructor.name);
+    }
+
+    try {
+      // TODO(vorshen): 考虑异常情况
+      for (const disposable of this._toDispose) {
+        disposable.dispose();
+      }
+    } finally {
+      this._toDispose.clear();
+    }
+  }
+
+  add<T extends IDisposable>(o: T): T {
+    if (!o) {
+      return o;
+    }
+    if ((o as unknown as DisposableStore) === this) {
+      throw new Error('Cannot register a disposable on itself.');
+    }
+
+    if (this._isDisposed) {
+      if (!DisposableStore.DISABLE_DISPOSED_WARNING) {
+        /* eslint-disable no-console */
+        console.warn(
+          new Error(
+            'Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!',
+          ).stack,
+        );
+      }
+    } else {
+      this._toDispose.add(o);
+    }
+
+    return o;
+  }
+}