@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

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();
+  }
 }

package/data-structures/collection.js

@@ -1,88 +1,111 @@
-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);
+"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();
     }
+  }
+  /** 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);
+  }
 }