@zk-tech/bedrock 0.0.1

package/dist/lock/index.cjs

@@ -0,0 +1,662 @@
+'use strict';
+
+// src/assert/assert.ts
+function abort(reason) {
+  throw new Error(`lvAssert(${reason})`);
+}
+function lvAssert(expr, reason) {
+  if (!expr) {
+    abort("#expr is false");
+  }
+}
+function lvAssertNotNil(val, reason) {
+  if (val === null || val === void 0) {
+    abort("#val is nil");
+  }
+}
+
+// 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/dispose/timer.ts
+function setDisposableTimeout(fn, timeout) {
+  const handle = setTimeout(() => {
+    fn();
+  }, timeout);
+  return makeSafeDisposable(() => clearTimeout(handle));
+}
+
+// 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/event/once.ts
+function listenOnce(event) {
+  return (listener, thisArgs = null) => {
+    let didFire = false;
+    let result = void 0;
+    result = event((...args) => {
+      if (didFire) {
+        return;
+      } else if (result) {
+        result.dispose();
+      } else {
+        didFire = true;
+      }
+      return listener.call(thisArgs, ...args);
+    }, null);
+    if (didFire) {
+      result.dispose();
+    }
+    return result;
+  };
+}
+
+// src/lock/capability.ts
+var Capability = class {
+  constructor() {
+    this._onUnlocked = new Emitter();
+    this._status = 0 /* Unlocked */;
+    this.onUnlocked = this._onUnlocked.event;
+  }
+  get status() {
+    return this._status;
+  }
+  acquire() {
+    lvAssert(this._status === 0 /* Unlocked */);
+    this._status = 1 /* Locked */;
+  }
+  release() {
+    lvAssert(this._status === 1 /* Locked */);
+    this._status = 0 /* Unlocked */;
+    this._onUnlocked.fire();
+  }
+};
+var SharedCapability = class {
+  constructor() {
+    this._onUnlocked = new Emitter();
+    this._status = 0 /* Unlocked */;
+    this._counter = 0;
+    this.onUnlocked = this._onUnlocked.event;
+  }
+  get status() {
+    return this._status;
+  }
+  get counter() {
+    return this._counter;
+  }
+  acquire() {
+    if (this._status === 0 /* Unlocked */) {
+      this._status = 1 /* Locked */;
+    }
+    this._counter++;
+  }
+  release() {
+    lvAssert(this._counter > 0);
+    this._counter--;
+    if (this._counter === 0) {
+      this._status = 0 /* Unlocked */;
+      this._onUnlocked.fire();
+    }
+  }
+};
+
+// src/lock/semaphore.ts
+var Semaphore = class {
+  constructor() {
+    this._onActive = new Emitter();
+    this.onActive = this._onActive.event;
+  }
+  notify() {
+    this._onActive.fire();
+  }
+};
+
+// src/lock/shared-mutex.ts
+var SharedMutex = class {
+  constructor() {
+    // 在第一道门外等待的写者
+    this._waitingWriters = [];
+  }
+  /**
+   * 是否被锁住
+   */
+  isLocked() {
+    return this._writer || this._readerCount !== 0;
+  }
+  /**
+   * 等待并获取写锁
+   */
+  lock() {
+    return new Promise((resolve) => {
+      if (this._writer) {
+        const token = new Semaphore();
+        this._waitingWriters.push(token);
+        token.onActive(() => {
+          this._writerEnterGate1(resolve);
+        });
+      } else {
+        this._writerEnterGate1(resolve);
+      }
+    });
+  }
+  /**
+   * 尝试获取写锁，立刻返回结果
+   */
+  tryLock() {
+    if (this._writer || this._readerCount > 0) {
+      return false;
+    }
+    this.lock();
+    return true;
+  }
+  /**
+   * 解除写锁
+   */
+  unLock() {
+    lvAssertNotNil(this._writer);
+    this._writer.release();
+  }
+  /**
+   * 等待并获取读锁
+   */
+  lockShared() {
+    return new Promise((resolve) => {
+      if (this._writer) {
+        if (!this._waitingReader) {
+          this._waitingReader = new Semaphore();
+        }
+        this._waitingReader.onActive(() => {
+          this._readerEnterGate1(resolve);
+        });
+      } else {
+        this._readerEnterGate1(resolve);
+      }
+    });
+  }
+  /**
+   * 尝试获取读锁，立刻返回结果
+   */
+  tryLockShared() {
+    if (this._writer) {
+      return false;
+    }
+    this.lockShared();
+    return true;
+  }
+  /**
+   * 解除读锁
+   */
+  unLockShared() {
+    lvAssertNotNil(this._reader);
+    if (this._writer) {
+      lvAssert(this._writer.status === 0 /* Unlocked */);
+    }
+    this._reader.release();
+  }
+  /**
+   * 获取当前读者数量
+   */
+  get _readerCount() {
+    return this._reader ? this._reader.counter : 0;
+  }
+  /**
+   * 写者进入第一道门
+   */
+  _writerEnterGate1(resolve) {
+    lvAssert(!this._writer);
+    this._writer = new Capability();
+    if (this._readerCount > 0) {
+      listenOnce(this._reader.onUnlocked)(() => {
+        this._writerEnterGate2(resolve);
+      });
+    } else {
+      this._writerEnterGate2(resolve);
+    }
+  }
+  /**
+   * 写者进入第二道门
+   */
+  _writerEnterGate2(resolve) {
+    lvAssertNotNil(this._writer);
+    lvAssert(this._readerCount === 0);
+    this._writer.acquire();
+    listenOnce(this._writer.onUnlocked)(() => {
+      lvAssertNotNil(this._writer);
+      this._writer = void 0;
+      this._moveForward();
+    });
+    resolve();
+  }
+  /**
+   * 读者进入第一道门
+   */
+  _readerEnterGate1(resolve) {
+    lvAssert(!this._writer);
+    this._waitingReader = void 0;
+    if (!this._reader) {
+      this._reader = new SharedCapability();
+      this._reader.acquire();
+      listenOnce(this._reader.onUnlocked)(() => {
+        this._moveForward();
+      });
+    } else {
+      this._reader.acquire();
+    }
+    resolve();
+  }
+  /**
+   * 锁释放时推进流程
+   */
+  _moveForward() {
+    if (this._writer) {
+      return;
+    }
+    if (this._waitingWriters.length > 0) {
+      const semaphore = this._waitingWriters.shift();
+      semaphore.notify();
+      return;
+    }
+    if (this._waitingReader) {
+      this._waitingReader.notify();
+    }
+  }
+};
+
+// src/lock/utils.ts
+async function transferLock(mutex, timeout) {
+  await mutex.lock();
+  let didUnlock = false;
+  let timerDisposable;
+  if (timeout !== void 0) {
+    timerDisposable = setDisposableTimeout(() => {
+      if (!didUnlock) {
+        mutex.unLock();
+        didUnlock = true;
+      }
+    }, timeout);
+  }
+  const unlock = () => {
+    timerDisposable?.dispose();
+    if (!didUnlock) {
+      mutex.unLock();
+      didUnlock = true;
+    }
+  };
+  return {
+    dispose: unlock,
+    unlock
+  };
+}
+function tryTransferLock(mutex, timeout) {
+  if (!mutex.tryLock()) {
+    return;
+  }
+  let didUnlock = false;
+  let timerDisposable;
+  if (timeout !== void 0) {
+    timerDisposable = setDisposableTimeout(() => {
+      if (!didUnlock) {
+        mutex.unLock();
+        didUnlock = true;
+      }
+    }, timeout);
+  }
+  const unlock = () => {
+    timerDisposable?.dispose();
+    if (!didUnlock) {
+      mutex.unLock();
+      didUnlock = true;
+    }
+  };
+  return {
+    dispose: unlock,
+    unlock
+  };
+}
+async function transferSharedLock(mutex, timeout) {
+  await mutex.lockShared();
+  let didUnlock = false;
+  let timerDisposable;
+  if (timeout !== void 0) {
+    timerDisposable = setDisposableTimeout(() => {
+      if (!didUnlock) {
+        mutex.unLockShared();
+        didUnlock = true;
+      }
+    }, timeout);
+  }
+  const unlock = () => {
+    timerDisposable?.dispose();
+    if (!didUnlock) {
+      mutex.unLockShared();
+      didUnlock = true;
+    }
+  };
+  return {
+    dispose: unlock,
+    unlock
+  };
+}
+function tryTransferSharedLock(mutex, timeout) {
+  if (!mutex.tryLockShared()) {
+    return;
+  }
+  let didUnlock = false;
+  let timerDisposable;
+  if (timeout !== void 0) {
+    timerDisposable = setDisposableTimeout(() => {
+      if (!didUnlock) {
+        mutex.unLockShared();
+        didUnlock = true;
+      }
+    }, timeout);
+  }
+  const unlock = () => {
+    timerDisposable?.dispose();
+    if (!didUnlock) {
+      mutex.unLockShared();
+      didUnlock = true;
+    }
+  };
+  return {
+    dispose: unlock,
+    unlock
+  };
+}
+
+exports.SharedMutex = SharedMutex;
+exports.transferLock = transferLock;
+exports.transferSharedLock = transferSharedLock;
+exports.tryTransferLock = tryTransferLock;
+exports.tryTransferSharedLock = tryTransferSharedLock;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map