@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/data-structures/cache.js

@@ -1,46 +1,69 @@
-export class Cache {
-    cache;
-    _capacity;
-    get capacity() {
-        return this._capacity;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_exports = {};
+__export(cache_exports, {
+  Cache: () => Cache
+});
+module.exports = __toCommonJS(cache_exports);
+class Cache {
+  cache;
+  _capacity;
+  get capacity() {
+    return this._capacity;
+  }
+  set capacity(capacity) {
+    this.removeEntries(this._capacity - capacity);
+    this._capacity = capacity;
+  }
+  constructor(capacity) {
+    this._capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
     }
-    set capacity(capacity) {
-        this.removeEntries(this._capacity - capacity);
-        this._capacity = capacity;
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    const isNew = !this.cache.has(key);
+    if (isNew && this.cache.size >= this.capacity) {
+      this.removeEntries(1);
     }
-    constructor(capacity) {
-        this._capacity = capacity;
-        this.cache = new Map();
+    this.cache.set(key, value);
+  }
+  delete(key) {
+    this.delete(key);
+  }
+  removeEntries(count) {
+    if (count <= 0) {
+      return;
     }
-    get(key) {
-        if (!this.cache.has(key)) {
-            return undefined;
-        }
-        const value = this.cache.get(key);
-        this.cache.delete(key);
-        this.cache.set(key, value);
-        return value;
-    }
-    set(key, value) {
-        const isNew = !this.cache.has(key);
-        if (isNew && (this.cache.size >= this.capacity)) {
-            this.removeEntries(1);
-        }
-        this.cache.set(key, value);
-    }
-    delete(key) {
-        this.delete(key);
-    }
-    removeEntries(count) {
-        if (count <= 0) {
-            return;
-        }
-        let left = count;
-        for (const key of this.cache.keys()) {
-            if (left-- <= 0) {
-                return;
-            }
-            this.cache.delete(key);
-        }
+    let left = count;
+    for (const key of this.cache.keys()) {
+      if (left-- <= 0) {
+        return;
+      }
+      this.cache.delete(key);
     }
+  }
 }

package/data-structures/circular-buffer.js

@@ -1,197 +1,221 @@
-import { CancellationToken } from '../utils/cancellation-token.js';
-import { isArray, isDefined, isUndefined } from '../utils/type-guards.js';
-import { BehaviorSubject, distinctUntilChanged, filter, first, firstValueFrom, from, map, race, Subject } from 'rxjs';
-import { Collection } from './collection.js';
-export class CircularBuffer extends Collection {
-    maxBufferSizeSubject;
-    overflowSubject;
-    backingArray;
-    writeIndex;
-    readIndex;
-    /** emits overwritten items */
-    overflow$;
-    /** emits count of free slots in the buffer */
-    freeSlots$;
-    /** emits when the buffer is full */
-    onFull$;
-    /** emits when the buffer has free slots */
-    onFreeSlots$;
-    /** emits whether the buffer is full */
-    isFull$;
-    /** emits whether the buffer has free slots */
-    hasFreeSlots$;
-    /** resolves when the buffer is full */
-    get $onFull() {
-        return firstValueFrom(this.onFull$);
-    }
-    /** resolves when the buffer has items */
-    get $onFreeSlots() {
-        return firstValueFrom(this.onFreeSlots$);
-    }
-    /** size of buffer */
-    get bufferSize() {
-        return this.backingArray.length;
-    }
-    /** size of buffer */
-    get maxBufferSize() {
-        return this.maxBufferSizeSubject.value ?? Infinity;
-    }
-    /** count of free slots in buffer */
-    get freeSlots() {
-        if (isUndefined(this.maxBufferSize)) {
-            return Infinity;
-        }
-        return this.bufferSize - this.size;
-    }
-    /** whether the buffer is full */
-    get isFull() {
-        return this.freeSlots == 0;
-    }
-    /** whether the buffer has free slots */
-    get hasFreeSlots() {
-        return this.freeSlots > 0;
-    }
-    constructor(maxBufferSize) {
-        super();
-        this.maxBufferSizeSubject = new BehaviorSubject(maxBufferSize);
-        this.overflowSubject = new Subject();
-        this.overflow$ = this.overflowSubject.asObservable();
-        this.freeSlots$ = this.change$.pipe(map(() => this.freeSlots));
-        this.isFull$ = this.change$.pipe(map(() => this.isFull), distinctUntilChanged());
-        this.hasFreeSlots$ = this.change$.pipe(map(() => this.hasFreeSlots), distinctUntilChanged());
-        this.onFull$ = this.isFull$.pipe(filter((isFull) => isFull), map(() => undefined));
-        this.onFreeSlots$ = this.hasFreeSlots$.pipe(filter((hasFreeSlots) => hasFreeSlots), map(() => undefined));
-        this.clear();
-    }
-    includes(item) {
-        for (const entry of this) {
-            if (entry === item) {
-                return true;
-            }
-        }
-        return false;
-    }
-    add(item) {
-        this.increaseBufferSizeIfNeeded();
-        const overwrite = this.isFull;
-        const overwrittenItem = overwrite ? this.backingArray[this.writeIndex] : undefined;
-        this.backingArray[this.writeIndex] = item;
-        this.writeIndex = (this.writeIndex + 1) % this.bufferSize;
-        if (overwrite) {
-            this.readIndex = (this.readIndex + 1) % this.bufferSize;
-            this.overflowSubject.next(overwrittenItem);
-            this.emitChange();
-            return;
-        }
-        this.incrementSize();
-    }
-    addMany(items) {
-        const increase = isArray(items) ? items.length : (items instanceof Collection) ? items.size : 1;
-        this.increaseBufferSizeIfNeeded(this.size + increase);
-        for (const item of items) {
-            this.add(item);
-        }
-    }
-    remove() {
-        if (this.size == 0) {
-            throw new Error('buffer is empty');
-        }
-        return this.tryRemove();
-    }
-    tryRemove() {
-        if (this.size == 0) {
-            return undefined;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var circular_buffer_exports = {};
+__export(circular_buffer_exports, {
+  CircularBuffer: () => CircularBuffer
+});
+module.exports = __toCommonJS(circular_buffer_exports);
+var import_cancellation_token = require("../utils/cancellation-token.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_rxjs = require("rxjs");
+var import_collection = require("./collection.js");
+class CircularBuffer extends import_collection.Collection {
+  maxBufferSizeSubject;
+  overflowSubject;
+  backingArray;
+  writeIndex;
+  readIndex;
+  /** emits overwritten items */
+  overflow$;
+  /** emits count of free slots in the buffer */
+  freeSlots$;
+  /** emits when the buffer is full */
+  onFull$;
+  /** emits when the buffer has free slots */
+  onFreeSlots$;
+  /** emits whether the buffer is full */
+  isFull$;
+  /** emits whether the buffer has free slots */
+  hasFreeSlots$;
+  /** resolves when the buffer is full */
+  get $onFull() {
+    return (0, import_rxjs.firstValueFrom)(this.onFull$);
+  }
+  /** resolves when the buffer has items */
+  get $onFreeSlots() {
+    return (0, import_rxjs.firstValueFrom)(this.onFreeSlots$);
+  }
+  /** size of buffer */
+  get bufferSize() {
+    return this.backingArray.length;
+  }
+  /** size of buffer */
+  get maxBufferSize() {
+    return this.maxBufferSizeSubject.value ?? Infinity;
+  }
+  /** count of free slots in buffer */
+  get freeSlots() {
+    if ((0, import_type_guards.isUndefined)(this.maxBufferSize)) {
+      return Infinity;
+    }
+    return this.bufferSize - this.size;
+  }
+  /** whether the buffer is full */
+  get isFull() {
+    return this.freeSlots == 0;
+  }
+  /** whether the buffer has free slots */
+  get hasFreeSlots() {
+    return this.freeSlots > 0;
+  }
+  constructor(maxBufferSize) {
+    super();
+    this.maxBufferSizeSubject = new import_rxjs.BehaviorSubject(maxBufferSize);
+    this.overflowSubject = new import_rxjs.Subject();
+    this.overflow$ = this.overflowSubject.asObservable();
+    this.freeSlots$ = this.change$.pipe((0, import_rxjs.map)(() => this.freeSlots));
+    this.isFull$ = this.change$.pipe((0, import_rxjs.map)(() => this.isFull), (0, import_rxjs.distinctUntilChanged)());
+    this.hasFreeSlots$ = this.change$.pipe((0, import_rxjs.map)(() => this.hasFreeSlots), (0, import_rxjs.distinctUntilChanged)());
+    this.onFull$ = this.isFull$.pipe((0, import_rxjs.filter)((isFull) => isFull), (0, import_rxjs.map)(() => void 0));
+    this.onFreeSlots$ = this.hasFreeSlots$.pipe((0, import_rxjs.filter)((hasFreeSlots) => hasFreeSlots), (0, import_rxjs.map)(() => void 0));
+    this.clear();
+  }
+  includes(item) {
+    for (const entry of this) {
+      if (entry === item) {
+        return true;
+      }
+    }
+    return false;
+  }
+  add(item) {
+    this.increaseBufferSizeIfNeeded();
+    const overwrite = this.isFull;
+    const overwrittenItem = overwrite ? this.backingArray[this.writeIndex] : void 0;
+    this.backingArray[this.writeIndex] = item;
+    this.writeIndex = (this.writeIndex + 1) % this.bufferSize;
+    if (overwrite) {
+      this.readIndex = (this.readIndex + 1) % this.bufferSize;
+      this.overflowSubject.next(overwrittenItem);
+      this.emitChange();
+      return;
+    }
+    this.incrementSize();
+  }
+  addMany(items) {
+    const increase = (0, import_type_guards.isArray)(items) ? items.length : items instanceof import_collection.Collection ? items.size : 1;
+    this.increaseBufferSizeIfNeeded(this.size + increase);
+    for (const item of items) {
+      this.add(item);
+    }
+  }
+  remove() {
+    if (this.size == 0) {
+      throw new Error("buffer is empty");
+    }
+    return this.tryRemove();
+  }
+  tryRemove() {
+    if (this.size == 0) {
+      return void 0;
+    }
+    const item = this.backingArray[this.readIndex];
+    this.backingArray[this.readIndex] = void 0;
+    this.readIndex = (this.readIndex + 1) % this.bufferSize;
+    this.decrementSize();
+    return item;
+  }
+  clone(newMaxBufferSize = this.maxBufferSize) {
+    if ((0, import_type_guards.isDefined)(newMaxBufferSize) && newMaxBufferSize < this.size) {
+      throw new Error("newSize must be equal or larger to current size");
+    }
+    const cloned = new CircularBuffer(newMaxBufferSize);
+    cloned.addMany(this);
+    return cloned;
+  }
+  *items() {
+    const size = this.size;
+    let readIndex = this.readIndex;
+    let modified = false;
+    const subscription = (0, import_rxjs.from)(this.change$).pipe((0, import_rxjs.first)()).subscribe(() => modified = true);
+    try {
+      for (let i = 0; i < size; i++) {
+        if (modified) {
+          throw new Error("buffer was modified while being iterated");
         }
-        const item = this.backingArray[this.readIndex];
-        this.backingArray[this.readIndex] = undefined;
-        this.readIndex = (this.readIndex + 1) % this.bufferSize;
-        this.decrementSize();
-        return item;
-    }
-    clone(newMaxBufferSize = this.maxBufferSize) {
-        if (isDefined(newMaxBufferSize) && (newMaxBufferSize < this.size)) {
-            throw new Error('newSize must be equal or larger to current size');
-        }
-        const cloned = new CircularBuffer(newMaxBufferSize);
-        cloned.addMany(this);
-        return cloned;
-    }
-    *items() {
-        const size = this.size;
-        let readIndex = this.readIndex;
-        let modified = false;
-        const subscription = from(this.change$).pipe(first()).subscribe(() => (modified = true));
-        try {
-            for (let i = 0; i < size; i++) {
-                if (modified) {
-                    throw new Error('buffer was modified while being iterated');
-                }
-                yield this.backingArray[readIndex];
-                readIndex = (readIndex + 1) % this.bufferSize;
-            }
-        }
-        finally {
-            subscription.unsubscribe();
-        }
-    }
-    /** yields all items from the buffer and removes them */
-    *consume() {
-        while (this.size > 0) {
-            yield this.tryRemove();
-        }
-    }
-    /**
-     * yields all items from the buffer, removes them and waits fore more
-     * @param cancellationToken token to cancel iteration
-     * @param yieldOutstandingItems whether to yield all outstanding items or exit immdiately when {@link cancellationToken} is set
-     * @returns
-     */
-    async *consumeAsync(cancellationToken = new CancellationToken(), yieldOutstandingItems = true) {
-        while (true) {
-            if (this.isEmpty) {
-                await firstValueFrom(race([this.onItems$, cancellationToken]));
-            }
-            while ((this.size > 0) && (cancellationToken.isUnset || yieldOutstandingItems)) {
-                yield this.tryRemove();
-            }
-            if (cancellationToken.isSet) {
-                return;
-            }
-        }
-    }
-    _clear() {
-        this.backingArray = new Array(2);
-        this.writeIndex = 0;
-        this.readIndex = 0;
-    }
-    increaseBufferSizeIfNeeded(requiredCapacity = this.size + 1) {
-        if (requiredCapacity <= this.bufferSize) {
-            return;
-        }
-        const newSize = Math.min(2 ** Math.ceil(Math.log2(requiredCapacity)), this.maxBufferSize);
-        if (newSize != this.bufferSize) {
-            this.resize(newSize);
-        }
-    }
-    resize(size) {
-        if (size < this.size) {
-            throw new Error('buffer has more items than it would have capacity after resize');
-        }
-        let newBackingArray = [];
-        if (this.size > 0) {
-            if (this.readIndex < this.writeIndex) {
-                newBackingArray = this.backingArray.slice(this.readIndex, this.writeIndex);
-            }
-            else {
-                const start = this.backingArray.slice(this.readIndex);
-                const end = this.backingArray.slice(0, this.writeIndex);
-                newBackingArray = start.concat(end);
-            }
-        }
-        newBackingArray.length = size;
-        this.backingArray = newBackingArray;
-        this.writeIndex = this.size % this.backingArray.length;
-        this.readIndex = 0;
-        this.emitChange();
-    }
+        yield this.backingArray[readIndex];
+        readIndex = (readIndex + 1) % this.bufferSize;
+      }
+    } finally {
+      subscription.unsubscribe();
+    }
+  }
+  /** yields all items from the buffer and removes them */
+  *consume() {
+    while (this.size > 0) {
+      yield this.tryRemove();
+    }
+  }
+  /**
+   * yields all items from the buffer, removes them and waits fore more
+   * @param cancellationToken token to cancel iteration
+   * @param yieldOutstandingItems whether to yield all outstanding items or exit immdiately when {@link cancellationToken} is set
+   * @returns
+   */
+  async *consumeAsync(cancellationToken = new import_cancellation_token.CancellationToken(), yieldOutstandingItems = true) {
+    while (true) {
+      if (this.isEmpty) {
+        await (0, import_rxjs.firstValueFrom)((0, import_rxjs.race)([this.onItems$, cancellationToken]));
+      }
+      while (this.size > 0 && (cancellationToken.isUnset || yieldOutstandingItems)) {
+        yield this.tryRemove();
+      }
+      if (cancellationToken.isSet) {
+        return;
+      }
+    }
+  }
+  _clear() {
+    this.backingArray = [];
+    this.backingArray.length = 2;
+    this.writeIndex = 0;
+    this.readIndex = 0;
+  }
+  increaseBufferSizeIfNeeded(requiredCapacity = this.size + 1) {
+    if (requiredCapacity <= this.bufferSize) {
+      return;
+    }
+    const newSize = Math.min(2 ** Math.ceil(Math.log2(requiredCapacity)), this.maxBufferSize);
+    if (newSize != this.bufferSize) {
+      this.resize(newSize);
+    }
+  }
+  resize(size) {
+    if (size < this.size) {
+      throw new Error("buffer has more items than it would have capacity after resize");
+    }
+    let newBackingArray;
+    if (this.size > 0) {
+      if (this.readIndex < this.writeIndex) {
+        newBackingArray = this.backingArray.slice(this.readIndex, this.writeIndex);
+      } else {
+        const start = this.backingArray.slice(this.readIndex);
+        const end = this.backingArray.slice(0, this.writeIndex);
+        newBackingArray = start.concat(end);
+      }
+    } else {
+      newBackingArray = [];
+    }
+    newBackingArray.length = size;
+    this.backingArray = newBackingArray;
+    this.writeIndex = this.size % this.backingArray.length;
+    this.readIndex = 0;
+    this.emitChange();
+  }
 }