@zk-tech/bedrock 0.0.1

package/dist/promise/index.js

@@ -0,0 +1,633 @@
+// 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 makeOk() {
+  return {
+    ok: true,
+    value: null,
+    pair() {
+      return [null, null];
+    },
+    code: 0,
+    msg: "",
+    ...{ [lvErrorRefSymbol]: true }
+    // 跳过类型检测
+  };
+}
+function makeOkWith(value) {
+  return {
+    ok: true,
+    value,
+    pair() {
+      return [null, value];
+    },
+    code: 0,
+    msg: "",
+    ...{ [lvErrorRefSymbol]: true }
+    // 跳过类型检测
+  };
+}
+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 makeError(code, msg, errorInfo) {
+  return internalMakeError(code, msg, void 0, errorInfo);
+}
+function makeErrorBy(code, msg, cause, errorInfo) {
+  return internalMakeError(code, msg, cause, errorInfo);
+}
+function isLvErrorRef(val) {
+  return typeof val === "object" && val !== null && lvErrorRefSymbol in val;
+}
+
+// src/error/error-const.ts
+function lvErrorConst(code, msg) {
+  return (rewrite) => {
+    if (!rewrite) {
+      return makeError(code, msg);
+    }
+    if (typeof rewrite === "string") {
+      return makeError(code, rewrite);
+    }
+    return makeErrorBy(code, rewrite.message, rewrite);
+  };
+}
+
+// src/error/error-code.ts
+var cancelledError = lvErrorConst(1 /* Cancelled */, "operation(s) cancelled.");
+var timeoutError = lvErrorConst(2 /* TimedOut */, "operation(s) timed out.");
+
+// src/dispose/dispose-base.ts
+var EmptyDispose = Object.freeze({ dispose() {
+} });
+
+// src/dispose/disposable-t.ts
+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/promise/promise.ts
+function makeCancelablePromise(callback) {
+  const source = new CancellationTokenSource();
+  const thenable = callback(source.token);
+  const promise = new Promise((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));
+        }
+      },
+      (err) => {
+        subscription.dispose();
+        source.dispose();
+        reject(err);
+      }
+    );
+  });
+  return new class {
+    cancel() {
+      source.cancel();
+    }
+    then(resolve, reject) {
+      return promise.then(resolve, reject);
+    }
+    catch(reject) {
+      return this.then(void 0, reject);
+    }
+    finally(onfinally) {
+      return promise.finally(onfinally);
+    }
+  }();
+}
+function parallelPromise(promiseList) {
+  if (promiseList.length === 0) {
+    return Promise.resolve(makeOk());
+  }
+  let todo = promiseList.length;
+  const finish = () => {
+    todo = -1;
+    for (const promise of promiseList) {
+      promise.cancel?.();
+    }
+  };
+  return new Promise((resolve, reject) => {
+    for (const promise of promiseList) {
+      promise.then((res) => {
+        if (isLvErrorRef(res) && !res.ok) {
+          finish();
+          resolve(res);
+          return;
+        }
+        todo--;
+        if (todo === 0) {
+          resolve(makeOk());
+        }
+      }).catch((err) => {
+        finish();
+        reject(err);
+      });
+    }
+  });
+}
+function makePromiseWithTimeout(callback, timeout, defaultValue) {
+  const cancellable = makeCancelablePromise(callback);
+  const timer = setTimeout(() => {
+    cancellable.cancel();
+  }, timeout);
+  return cancellable.then((res) => {
+    clearTimeout(timer);
+    if (res.ok) {
+      return res;
+    }
+    if (res.code === 1 /* Cancelled */) {
+      if (defaultValue !== void 0) {
+        return makeOkWith(defaultValue);
+      }
+      return timeoutError();
+    } else {
+      return res;
+    }
+  });
+}
+function defer() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { resolve, reject, promise };
+}
+function waitForAbortSignal(signal) {
+  const { promise, reject } = defer();
+  if (signal.aborted) {
+    reject(signal.reason);
+  }
+  const handleAbort = () => {
+    reject(signal.reason);
+    signal.removeEventListener("abort", handleAbort);
+  };
+  signal.addEventListener("abort", handleAbort);
+  return promise;
+}
+
+export { defer, makeCancelablePromise, makePromiseWithTimeout, parallelPromise, waitForAbortSignal };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map