@tstdl/base 0.85.13 → 0.86.0-beta1

package/data-structures/circular-buffer.js

@@ -1,218 +1,197 @@
-"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");
+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;
         }
-        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 = 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();
-  }
+        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();
+    }
 }

package/data-structures/collection.js

@@ -1,111 +1,88 @@
-"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 collection_exports = {};
-__export(collection_exports, {
-  Collection: () => Collection
-});
-module.exports = __toCommonJS(collection_exports);
-var import_rxjs = require("rxjs");
-class Collection {
-  sizeSubject;
-  changeSubject;
-  clearSubject;
-  /** emits collection on subscribe and change */
-  observe$;
-  /** emits size of collection */
-  size$;
-  /** emits collection on change */
-  change$;
-  /* emits collection on clear */
-  clear$;
-  /** emits when the collection is empty */
-  onEmpty$;
-  /** emits when the collection has items */
-  onItems$;
-  /** emits whether the collection is empty */
-  isEmpty$;
-  /** emits whether the collection has items */
-  hasItems$;
-  /** resolves when the collection is empty */
-  get $onEmpty() {
-    return (0, import_rxjs.firstValueFrom)(this.onEmpty$);
-  }
-  /** resolves when the collection has items */
-  get $onItems() {
-    return (0, import_rxjs.firstValueFrom)(this.onItems$);
-  }
-  /** size of collection */
-  get size() {
-    return this.sizeSubject.value;
-  }
-  /** whether the collection is empty */
-  get isEmpty() {
-    return this.size == 0;
-  }
-  /** whether the collection has items */
-  get hasItems() {
-    return this.size > 0;
-  }
-  constructor() {
-    this.sizeSubject = new import_rxjs.BehaviorSubject(0);
-    this.changeSubject = new import_rxjs.Subject();
-    this.clearSubject = new import_rxjs.Subject();
-    this.size$ = this.sizeSubject.asObservable();
-    this.change$ = this.changeSubject.asObservable();
-    this.clear$ = this.clearSubject.asObservable();
-    this.observe$ = this.change$.pipe((0, import_rxjs.startWith)(this));
-    this.isEmpty$ = this.size$.pipe((0, import_rxjs.map)(() => this.isEmpty), (0, import_rxjs.distinctUntilChanged)());
-    this.hasItems$ = this.size$.pipe((0, import_rxjs.map)(() => this.hasItems), (0, import_rxjs.distinctUntilChanged)());
-    this.onEmpty$ = this.isEmpty$.pipe((0, import_rxjs.filter)((isEmpty) => isEmpty), (0, import_rxjs.map)(() => void 0));
-    this.onItems$ = this.hasItems$.pipe((0, import_rxjs.filter)((hasItems) => hasItems), (0, import_rxjs.map)(() => void 0));
-  }
-  [Symbol.iterator]() {
-    return this.items();
-  }
-  toArray() {
-    return [...this];
-  }
-  toJSON() {
-    return this.toArray();
-  }
-  /** remove all items */
-  clear() {
-    this._clear();
-    this.clearSubject.next(this);
-    this.setSize(0);
-  }
-  /** sets collection size */
-  setSize(size) {
-    if (size != this.size) {
-      this.sizeSubject.next(size);
-      this.emitChange();
+import { BehaviorSubject, distinctUntilChanged, filter, firstValueFrom, map, startWith, Subject } from 'rxjs';
+export class Collection {
+    sizeSubject;
+    changeSubject;
+    clearSubject;
+    /** emits collection on subscribe and change */
+    observe$;
+    /** emits size of collection */
+    size$;
+    /** emits collection on change */
+    change$;
+    /* emits collection on clear */
+    clear$;
+    /** emits when the collection is empty */
+    onEmpty$;
+    /** emits when the collection has items */
+    onItems$;
+    /** emits whether the collection is empty */
+    isEmpty$;
+    /** emits whether the collection has items */
+    hasItems$;
+    /** resolves when the collection is empty */
+    get $onEmpty() {
+        return firstValueFrom(this.onEmpty$);
+    }
+    /** resolves when the collection has items */
+    get $onItems() {
+        return firstValueFrom(this.onItems$);
+    }
+    /** size of collection */
+    get size() {
+        return this.sizeSubject.value;
+    }
+    /** whether the collection is empty */
+    get isEmpty() {
+        return this.size == 0;
+    }
+    /** whether the collection has items */
+    get hasItems() {
+        return this.size > 0;
+    }
+    constructor() {
+        this.sizeSubject = new BehaviorSubject(0);
+        this.changeSubject = new Subject();
+        this.clearSubject = new Subject();
+        this.size$ = this.sizeSubject.asObservable();
+        this.change$ = this.changeSubject.asObservable();
+        this.clear$ = this.clearSubject.asObservable();
+        this.observe$ = this.change$.pipe(startWith(this));
+        this.isEmpty$ = this.size$.pipe(map(() => this.isEmpty), distinctUntilChanged());
+        this.hasItems$ = this.size$.pipe(map(() => this.hasItems), distinctUntilChanged());
+        this.onEmpty$ = this.isEmpty$.pipe(filter((isEmpty) => isEmpty), map(() => undefined));
+        this.onItems$ = this.hasItems$.pipe(filter((hasItems) => hasItems), map(() => undefined));
+    }
+    [Symbol.iterator]() {
+        return this.items();
+    }
+    toArray() {
+        return [...this];
+    }
+    toJSON() {
+        return this.toArray();
+    }
+    /** remove all items */
+    clear() {
+        this._clear();
+        this.clearSubject.next(this);
+        this.setSize(0);
+    }
+    /** sets collection size */
+    setSize(size) {
+        if (size != this.size) {
+            this.sizeSubject.next(size);
+            this.emitChange();
+        }
+    }
+    /** increment collection size by amount (default 1) */
+    incrementSize(amount = 1) {
+        this.setSize(this.size + amount);
+    }
+    /** decrement collection size by amount (default 1) */
+    decrementSize(amount = 1) {
+        this.setSize(this.size - amount);
+    }
+    emitChange() {
+        this.changeSubject.next(this);
     }
-  }
-  /** increment collection size by amount (default 1) */
-  incrementSize(amount = 1) {
-    this.setSize(this.size + amount);
-  }
-  /** decrement collection size by amount (default 1) */
-  decrementSize(amount = 1) {
-    this.setSize(this.size - amount);
-  }
-  emitChange() {
-    this.changeSubject.next(this);
-  }
 }