@zk-tech/bedrock 0.0.1

package/dist/async/index.cjs

@@ -0,0 +1,746 @@
+'use strict';
+
+// src/_internal/logger.ts
+var Logger = {
+  error(...data) {
+    if (typeof console.error === "function") {
+      console.error(...data);
+    }
+  },
+  info(...data) {
+    if (typeof console.info === "function") {
+      console.info(...data);
+    }
+  },
+  log(...data) {
+    if (typeof console.log === "function") {
+      console.log(...data);
+    }
+  },
+  time(label) {
+    if (typeof console.time === "function") {
+      console.time(label);
+    }
+  },
+  timeEnd(label) {
+    if (typeof console.timeEnd === "function") {
+      console.timeEnd(label);
+    }
+  },
+  timeLog(label, ...data) {
+    if (typeof console.timeLog === "function") {
+      console.timeLog(label, ...data);
+    }
+  },
+  timeStamp(label) {
+    if (typeof console.timeStamp === "function") {
+      console.timeStamp(label);
+    }
+  },
+  trace(...data) {
+    if (typeof console.trace === "function") {
+      console.trace(...data);
+    }
+  },
+  warn(...data) {
+    if (typeof console.warn === "function") {
+      console.warn(...data);
+    }
+  },
+  profile(label) {
+    if (typeof console.profile === "function") {
+      console.profile(label);
+    }
+  },
+  profileEnd(label) {
+    if (typeof console.profileEnd === "function") {
+      console.profileEnd(label);
+    }
+  }
+};
+function BRANCH_DISPOSE(from, to) {
+}
+
+// src/dispose/dispose-base.ts
+var EmptyDispose = Object.freeze({ dispose() {
+} });
+function SET_PARENT_OF_DISPOSABLE(child, parent) {
+}
+
+// src/dispose/disposable-store.ts
+var _DisposableStore = class _DisposableStore {
+  constructor() {
+    this._toDispose = /* @__PURE__ */ new Set();
+    this._isDisposed = false;
+  }
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  dispose() {
+    if (this._isDisposed) {
+      Logger.warn(new Error("DisposableStore has disposed.").stack);
+      return;
+    }
+    this._isDisposed = true;
+    this.clear();
+  }
+  clear() {
+    if (this._toDispose.size === 0) {
+      return;
+    }
+    for (const disposable of this._toDispose) {
+      BRANCH_DISPOSE(this.constructor.name, disposable.constructor.name);
+    }
+    const errors = [];
+    for (const disposable of this._toDispose) {
+      try {
+        disposable.dispose();
+      } catch (e) {
+        errors.push(e);
+      }
+    }
+    this._toDispose.clear();
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "find error when dispose store.");
+    }
+  }
+  add(o) {
+    if (!o) {
+      return o;
+    }
+    if (o === this) {
+      throw new Error("Cannot register a disposable on itself.");
+    }
+    if (this._isDisposed) {
+      if (!_DisposableStore.DISABLE_DISPOSED_WARNING) {
+        Logger.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;
+  }
+};
+_DisposableStore.DISABLE_DISPOSED_WARNING = false;
+var DisposableStore = _DisposableStore;
+
+// src/dispose/disposable-t.ts
+var Disposable = class {
+  constructor() {
+    this._store = new DisposableStore();
+    SET_PARENT_OF_DISPOSABLE(this._store);
+  }
+  // 销毁该节点和所有的子节点
+  dispose() {
+    BRANCH_DISPOSE(this.constructor.name, this._store.constructor.name);
+    this._store.dispose();
+  }
+  // 挂载子节点
+  _register(o) {
+    if (o === this) {
+      throw new Error("Cannot register a disposable on itself!");
+    }
+    return this._store.add(o);
+  }
+};
+var SafeDisposable = class {
+  constructor(value) {
+    this._value = value;
+  }
+  get value() {
+    return this._value;
+  }
+  isEmpty() {
+    return this._value === void 0;
+  }
+  dispose() {
+    if (!this._value) {
+      return;
+    }
+    this._value.dispose();
+    this._value = void 0;
+  }
+};
+
+// src/dispose/disposable-utils.ts
+function makeSafeDisposable(fn) {
+  const disposable = new SafeDisposable({
+    dispose: fn
+  });
+  return disposable;
+}
+
+// src/structure/linked-list.ts
+var ListNode = class {
+  constructor(value, next = null, prev = null) {
+    this.value = value;
+    this.next = next;
+    this.prev = prev;
+  }
+};
+var LinkedList = class {
+  constructor() {
+    this._head = null;
+    this._tail = null;
+    this._count = 0;
+  }
+  get size() {
+    return this._count;
+  }
+  get firstNode() {
+    return this._head;
+  }
+  isEmpty() {
+    return this._head === null;
+  }
+  clear() {
+    let current = this._head;
+    while (current !== null) {
+      const next = current.next;
+      current.prev = null;
+      current.next = null;
+      current = next;
+    }
+    this._head = null;
+    this._tail = null;
+    this._count = 0;
+  }
+  unshift(value) {
+    const node = new ListNode(value);
+    if (this.isEmpty()) {
+      this._head = node;
+      this._tail = node;
+    } else {
+      const oldHead = this._head;
+      this._head = node;
+      node.next = oldHead;
+      oldHead.prev = node;
+    }
+    this._count++;
+    return this;
+  }
+  push(value) {
+    const node = new ListNode(value);
+    if (this.isEmpty()) {
+      this._head = node;
+      this._tail = node;
+    } else {
+      const oldTail = this._tail;
+      this._tail = node;
+      node.prev = oldTail;
+      oldTail.next = node;
+    }
+    this._count++;
+    return this;
+  }
+  shift() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    const node = this._head;
+    const value = node.value;
+    this._remove(node);
+    return value;
+  }
+  pop() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    const node = this._tail;
+    const value = node.value;
+    this._remove(node);
+    return value;
+  }
+  toArray() {
+    const result = [];
+    for (const value of this) {
+      result.push(value);
+    }
+    return result;
+  }
+  *[Symbol.iterator]() {
+    let current = this._head;
+    while (current !== null) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  _remove(node) {
+    if (node.prev === null && node.next === null && node !== this._head && node !== this._tail) {
+      return;
+    }
+    if (node === this._head) {
+      this._head = node.next;
+      if (this._head) {
+        this._head.prev = null;
+      }
+    }
+    if (node === this._tail) {
+      this._tail = node.prev;
+      if (this._tail) {
+        this._tail.next = null;
+      }
+    }
+    if (node.prev) {
+      node.prev.next = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    }
+    node.prev = null;
+    node.next = null;
+    this._count--;
+  }
+};
+
+// src/event/disposable-linked-list.ts
+var DisposableLinkedList = class extends LinkedList {
+  unshiftAndGetDisposableNode(value) {
+    this.unshift(value);
+    const node = this._head;
+    let hasRemoved = false;
+    return () => {
+      if (!hasRemoved) {
+        hasRemoved = true;
+        super._remove(node);
+      }
+    };
+  }
+  pushAndGetDisposableNode(value) {
+    this.push(value);
+    const node = this._tail;
+    let hasRemoved = false;
+    return () => {
+      if (!hasRemoved) {
+        hasRemoved = true;
+        super._remove(node);
+      }
+    };
+  }
+};
+
+// src/event/error-handler.ts
+function asyncUnexpectedError(e) {
+  setTimeout(() => {
+    throw e;
+  }, 0);
+}
+
+// src/event/emitter.ts
+var Listener = class {
+  constructor(callback, callbackThis) {
+    this._callback = callback;
+    this._callbackThis = callbackThis;
+  }
+  invoke(...args) {
+    this._callback.call(this._callbackThis, ...args);
+  }
+};
+var EventDeliveryQueueElement = class {
+  constructor(emitter, listener, event) {
+    this.emitter = emitter;
+    this.listener = listener;
+    this.event = event;
+  }
+};
+var EventDeliveryQueue = class {
+  constructor(_onListenerError = asyncUnexpectedError) {
+    this._onListenerError = _onListenerError;
+    this._queue = new DisposableLinkedList();
+  }
+  get size() {
+    return this._queue.size;
+  }
+  push(emitter, listener, event) {
+    this._queue.push(new EventDeliveryQueueElement(emitter, listener, event));
+  }
+  clear(emitter) {
+    const newQueue = new DisposableLinkedList();
+    for (const element of this._queue) {
+      if (element.emitter !== emitter) {
+        newQueue.push(element);
+      }
+    }
+    this._queue = newQueue;
+  }
+  deliver() {
+    while (this._queue.size > 0) {
+      const element = this._queue.shift();
+      try {
+        element.listener.invoke(...element.event);
+      } catch (e) {
+        this._onListenerError(e);
+      }
+    }
+  }
+};
+var Emitter = class {
+  constructor(options) {
+    this._disposed = false;
+    this._options = options;
+  }
+  get event() {
+    if (this._event) {
+      return this._event;
+    }
+    this._event = (callback, thisArgs) => {
+      const listener = new Listener(callback, thisArgs);
+      if (!this._listeners) {
+        this._listeners = new DisposableLinkedList();
+      }
+      const removeListener = this._listeners.pushAndGetDisposableNode(listener);
+      if (this._options?.onAddListener) {
+        this._options.onAddListener(this, callback, thisArgs);
+      }
+      const result = () => {
+        if (!this._disposed) {
+          removeListener();
+          if (this._options?.onRemoveListener) {
+            this._options.onRemoveListener(this, callback, thisArgs);
+          }
+        }
+      };
+      return makeSafeDisposable(result);
+    };
+    return this._event;
+  }
+  dispose() {
+    if (this._disposed) {
+      return;
+    }
+    this._disposed = true;
+    this._listeners?.clear();
+    this._deliveryQueue?.clear(this);
+  }
+  fire(...event) {
+    if (!this._listeners || this._listeners.size === 0) {
+      return;
+    }
+    if (this._listeners.size === 1) {
+      const listener = this._listeners.firstNode;
+      try {
+        listener.value.invoke(...event);
+      } catch (e) {
+        if (this._options?.onListenerError) {
+          this._options.onListenerError(e);
+        } else {
+          asyncUnexpectedError(e);
+        }
+      }
+      return;
+    }
+    this._deliveryQueue ?? (this._deliveryQueue = new EventDeliveryQueue(this._options?.onListenerError));
+    for (const listener of this._listeners) {
+      this._deliveryQueue.push(this, listener, event);
+    }
+    this._deliveryQueue.deliver();
+  }
+};
+
+// src/async/cancellation.ts
+var shortcutEvent = Object.freeze(function(callback, context) {
+  const handle = setTimeout(callback.bind(context), 0);
+  return {
+    dispose() {
+      clearTimeout(handle);
+    }
+  };
+});
+var MutableToken = class {
+  constructor() {
+    // 是否已经取消该异步调用
+    this._isCancelled = false;
+    this._emitter = null;
+  }
+  get reason() {
+    return this._reason;
+  }
+  // 获取当前是否已经取消该异步调用
+  get isCancellationRequested() {
+    return this._isCancelled;
+  }
+  // 外界可以监听异步取消发起
+  get onCancellationRequested() {
+    if (this._isCancelled) {
+      return shortcutEvent;
+    }
+    if (!this._emitter) {
+      this._emitter = new Emitter();
+    }
+    return this._emitter.event;
+  }
+  cancel(reason) {
+    if (!this._isCancelled) {
+      this._reason = reason;
+      this._isCancelled = true;
+      if (this._emitter) {
+        this._emitter.fire();
+        this.dispose();
+      }
+    }
+  }
+  dispose() {
+    if (this._emitter) {
+      this._emitter.dispose();
+      this._emitter = null;
+    }
+  }
+};
+var CancellationToken = class {
+};
+CancellationToken.None = Object.freeze({
+  isCancellationRequested: false,
+  onCancellationRequested: () => EmptyDispose
+});
+CancellationToken.Cancelled = Object.freeze({
+  isCancellationRequested: true,
+  onCancellationRequested: shortcutEvent
+});
+CancellationToken.Make = (reason) => {
+  return Object.freeze({
+    isCancellationRequested: true,
+    onCancellationRequested: shortcutEvent,
+    reason
+  });
+};
+var CancellationTokenSource = class {
+  constructor(parent) {
+    // 真正的token
+    this._token = void 0;
+    // 可能存在父级CancellationTokenSource
+    this._parentListener = void 0;
+    // 为了支持signal场景，所以在需要时会初始化浏览器提供的abortController原生结构
+    this._abortController = void 0;
+    this._parentListener = parent?.onCancellationRequested(this.cancel, this);
+  }
+  /**
+   * 传统的cancellation用法
+   */
+  get token() {
+    if (!this._token) {
+      this._token = new MutableToken();
+    }
+    return this._token;
+  }
+  /**
+   * 对齐浏览器提供的abortSignal，支持给fetch、axios等传参使用
+   */
+  get signal() {
+    if (this._abortController) {
+      return this._abortController.signal;
+    }
+    this._abortController = new AbortController();
+    if (this._token?.isCancellationRequested) {
+      this._abortController.abort();
+    }
+    return this._abortController.signal;
+  }
+  cancel(reason) {
+    if (!this._token) {
+      this._token = reason === void 0 ? CancellationToken.Cancelled : CancellationToken.Make(reason);
+    } else if (this._token instanceof MutableToken) {
+      this._token.cancel(reason);
+    }
+    if (this._abortController) {
+      this._abortController.abort(reason);
+    }
+  }
+  dispose(cancel = false) {
+    if (cancel) {
+      this.cancel();
+    }
+    this._parentListener?.dispose();
+    if (!this._token) {
+      this._token = CancellationToken.None;
+    } else if (this._token instanceof MutableToken) {
+      this._token.dispose();
+    }
+  }
+};
+
+// src/async/wait.ts
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var sleep = wait;
+
+// src/async/barrier.ts
+var Barrier = class {
+  constructor() {
+    this._isOpen = false;
+    this._promise = new Promise((c, e) => {
+      this._completePromise = c;
+      this._rejectPromise = e;
+    });
+  }
+  isOpen() {
+    return this._isOpen;
+  }
+  open() {
+    this._isOpen = true;
+    this._completePromise(true);
+  }
+  reject(e) {
+    this._rejectPromise(e);
+  }
+  wait() {
+    return this._promise;
+  }
+};
+function makeBarrierByPromise(promise, openWhenReject = false) {
+  const barrier = new Barrier();
+  promise.then(() => barrier.open()).catch((err) => {
+    if (openWhenReject) {
+      barrier.open();
+      throw err;
+    } else {
+      barrier.reject(err);
+    }
+  });
+  return barrier;
+}
+
+// src/error/error-t.ts
+var lvErrorRefSymbol = /* @__PURE__ */ Symbol("lvErrorRef");
+function findJsError(error) {
+  let obj = error;
+  while (obj) {
+    if (obj instanceof Error) {
+      return obj;
+    }
+    obj = obj.cause;
+  }
+  return new Error(error.toString());
+}
+function printCause(cause) {
+  if (cause === void 0) {
+    return "";
+  } else if (cause instanceof Error) {
+    return `
+caused by [jsError]${cause.name}-${cause.message}`;
+  } else {
+    return `
+caused by [${cause.code}]${cause.msg}${cause.ok ? "" : printCause(cause.cause)}`;
+  }
+}
+function internalMakeError(code, msg, cause, errorInfo) {
+  const errorRef = {
+    ok: false,
+    code,
+    msg,
+    cause,
+    errorInfo,
+    toString() {
+      return `[${code}]${msg}.${cause ? printCause(cause) : ""}`;
+    },
+    pair() {
+      return [errorRef, null];
+    },
+    stack: cause instanceof Error ? cause.stack : void 0,
+    findJsError: () => findJsError(errorRef),
+    ...{ [lvErrorRefSymbol]: true }
+    // 跳过类型检测
+  };
+  return errorRef;
+}
+function makeErrorBy(code, msg, cause, errorInfo) {
+  return internalMakeError(code, msg, cause, errorInfo);
+}
+
+// src/async/queue/task.ts
+var AsyncTask = class extends Disposable {
+  constructor(_callback, _cancellationToken) {
+    super();
+    this._callback = _callback;
+    this._cancellationToken = _cancellationToken;
+    this._onSuccess = this._store.add(new Emitter());
+    this.onSuccess = this._onSuccess.event;
+    this._onFailure = this._store.add(new Emitter());
+    this.onFailure = this._onFailure.event;
+    this._onCancel = this._store.add(new Emitter());
+    this.onCancel = this._onCancel.event;
+    this._isExec = false;
+    this._isCancel = false;
+    this._cancellationToken?.onCancellationRequested(() => {
+      this.cancel();
+    });
+  }
+  /** 这个方法不对外暴露，只提供给 queue 使用. */
+  async safeExec() {
+    if (this._isCancel || this._isExec) {
+      return;
+    }
+    try {
+      this._isExec = true;
+      await this._callback(this._cancellationToken ?? CancellationToken.None);
+      this._onSuccess.fire();
+    } catch (err) {
+      this._onFailure.fire(makeErrorBy(-1, "exec error", err));
+    }
+  }
+  cancel() {
+    if (this._isCancel) {
+      return;
+    }
+    if (this._isExec) {
+      return;
+    }
+    this._isCancel = true;
+    this._callback = null;
+    this._onCancel.fire();
+  }
+};
+
+// src/async/queue/queue.ts
+var AsyncQueue = class extends Disposable {
+  constructor(options) {
+    super();
+    this._queue = [];
+    this._maxConcurrent = 1;
+    this._execCounter = 0;
+    this._maxConcurrent = options.concurrent;
+  }
+  /** 添加一个异步任务到队列 */
+  addTask(callback, cancellationToken) {
+    if (cancellationToken?.isCancellationRequested) {
+      return new AsyncTask(null);
+    }
+    const task = new AsyncTask(callback);
+    this._queue.push(this._store.add(task));
+    this._next();
+    return task;
+  }
+  // 执行下一个任务，如果当前并发数小于最大并发数，并且队列不为空，则从队列中取出一个任务并执行，否则什么都不做
+  _next() {
+    if (this._queue.length && this._execCounter < this._maxConcurrent && this._queue.length > 0) {
+      const task = this._queue.shift();
+      this._execCounter++;
+      task.safeExec().finally(() => {
+        this._execCounter--;
+        this._next();
+      });
+    }
+  }
+};
+
+// src/async/utils.ts
+function invokeNextLoop(fn) {
+  const handle = setTimeout(() => {
+    fn();
+  }, 0);
+  return makeSafeDisposable(() => clearTimeout(handle));
+}
+
+exports.AsyncQueue = AsyncQueue;
+exports.Barrier = Barrier;
+exports.CancellationTokenSource = CancellationTokenSource;
+exports.invokeNextLoop = invokeNextLoop;
+exports.makeBarrierByPromise = makeBarrierByPromise;
+exports.sleep = sleep;
+exports.wait = wait;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map