@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

package/utils/patch-worker.js

@@ -1,75 +1,96 @@
-import { debounceTime, defaultIfEmpty, firstValueFrom, merge, Subject, takeUntil } from 'rxjs';
-import { CancellationToken } from './cancellation-token.js';
-import { timeout } from './timing.js';
-import { isDefined, isObject, isUndefined } from './type-guards.js';
-const defaultDebounceTime = 5000;
-const defaultRetryDelay = 10000;
-export class PatchWorker {
-    patchAddedSubject;
-    handleSubject;
-    completeToken;
-    options;
-    patch;
-    constructor(options) {
-        this.options = options;
-        this.patchAddedSubject = new Subject();
-        this.handleSubject = new Subject();
-        this.completeToken = new CancellationToken();
-        this.patch = undefined;
-        if (isDefined(options.handleOn)) {
-            this.handleOn(options.handleOn);
-        }
-        if (isDefined(options.completeOn)) {
-            this.completeOn(options.completeOn);
-        }
-        void this.handleLoop();
+"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 patch_worker_exports = {};
+__export(patch_worker_exports, {
+  PatchWorker: () => PatchWorker
+});
+module.exports = __toCommonJS(patch_worker_exports);
+var import_rxjs = require("rxjs");
+var import_cancellation_token = require("./cancellation-token.js");
+var import_timing = require("./timing.js");
+var import_type_guards = require("./type-guards.js");
+const defaultDebounceTime = 5e3;
+const defaultRetryDelay = 1e4;
+class PatchWorker {
+  patchAddedSubject;
+  handleSubject;
+  completeToken;
+  options;
+  patch;
+  constructor(options) {
+    this.options = options;
+    this.patchAddedSubject = new import_rxjs.Subject();
+    this.handleSubject = new import_rxjs.Subject();
+    this.completeToken = new import_cancellation_token.CancellationToken();
+    this.patch = void 0;
+    if ((0, import_type_guards.isDefined)(options.handleOn)) {
+      this.handleOn(options.handleOn);
     }
-    handleOn(observable) {
-        observable.pipe(takeUntil(this.completeToken)).subscribe(() => this.handle());
+    if ((0, import_type_guards.isDefined)(options.completeOn)) {
+      this.completeOn(options.completeOn);
     }
-    completeOn(observable) {
-        observable.pipe(takeUntil(this.completeToken)).subscribe(() => this.complete());
+    void this.handleLoop();
+  }
+  handleOn(observable) {
+    observable.pipe((0, import_rxjs.takeUntil)(this.completeToken)).subscribe(() => this.handle());
+  }
+  completeOn(observable) {
+    observable.pipe((0, import_rxjs.takeUntil)(this.completeToken)).subscribe(() => this.complete());
+  }
+  add(patchOrKey, value) {
+    if (this.completeToken.isSet) {
+      throw new Error("instance is completed");
     }
-    add(patchOrKey, value) {
-        if (this.completeToken.isSet) {
-            throw new Error('instance is completed');
-        }
-        if (isObject(patchOrKey)) {
-            this.patch = { ...this.patch, ...patchOrKey };
-        }
-        else {
-            this.patch = { ...this.patch, [patchOrKey]: value };
-        }
-        this.patchAddedSubject.next();
+    if ((0, import_type_guards.isObject)(patchOrKey)) {
+      this.patch = { ...this.patch, ...patchOrKey };
+    } else {
+      this.patch = { ...this.patch, [patchOrKey]: value };
     }
-    handle() {
-        this.handleSubject.next();
-    }
-    complete() {
-        this.patchAddedSubject.complete();
-        this.handleSubject.next();
-        this.handleSubject.complete();
-        this.completeToken.set();
-    }
-    async handleLoop() {
-        const debounce$ = this.patchAddedSubject.pipe(debounceTime(this.options.debounceTime ?? defaultDebounceTime));
-        const handle$ = merge(debounce$, this.handleSubject).pipe(takeUntil(this.completeToken), defaultIfEmpty(undefined));
-        let patch;
-        while (this.completeToken.isUnset || isDefined(patch) || isDefined(this.patch)) {
-            await firstValueFrom(handle$);
-            if (isUndefined(patch) && isUndefined(this.patch)) {
-                continue;
-            }
-            patch = { ...patch, ...this.patch };
-            this.patch = undefined;
-            try {
-                await this.options.handler(patch);
-                patch = undefined;
-            }
-            catch (error) {
-                await this.options.errorHandler?.(error);
-                await timeout(this.options.retryDelay ?? defaultRetryDelay);
-            }
-        }
+    this.patchAddedSubject.next();
+  }
+  handle() {
+    this.handleSubject.next();
+  }
+  complete() {
+    this.patchAddedSubject.complete();
+    this.handleSubject.next();
+    this.handleSubject.complete();
+    this.completeToken.set();
+  }
+  async handleLoop() {
+    const debounce$ = this.patchAddedSubject.pipe((0, import_rxjs.debounceTime)(this.options.debounceTime ?? defaultDebounceTime));
+    const handle$ = (0, import_rxjs.merge)(debounce$, this.handleSubject).pipe((0, import_rxjs.takeUntil)(this.completeToken), (0, import_rxjs.defaultIfEmpty)(void 0));
+    let patch;
+    while (this.completeToken.isUnset || (0, import_type_guards.isDefined)(patch) || (0, import_type_guards.isDefined)(this.patch)) {
+      await (0, import_rxjs.firstValueFrom)(handle$);
+      if ((0, import_type_guards.isUndefined)(patch) && (0, import_type_guards.isUndefined)(this.patch)) {
+        continue;
+      }
+      patch = { ...patch, ...this.patch };
+      this.patch = void 0;
+      try {
+        await this.options.handler(patch);
+        patch = void 0;
+      } catch (error) {
+        await this.options.errorHandler?.(error);
+        await (0, import_timing.timeout)(this.options.retryDelay ?? defaultRetryDelay);
+      }
     }
+  }
 }

package/utils/patterns.js

@@ -1,8 +1,30 @@
-/** pattern matching valid JavaScript number literals including binary, octal and hexadecimal format but *not* Infinity and NaN */
-export const numberPattern = /^[+-]?(?:\d*\.?\d+|\d+\.?\d*|0[bB][01]+|0[xX][\da-fA-F]+|0[oO][0-7]+)$/u;
-/** pattern matching valid email addresses */
-// eslint-disable-next-line no-control-regex
-export const mailPattern = /^(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-zA-Z0-9-]*[a-zA-Z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/u;
-export function isEmail(value) {
-    return mailPattern.test(value);
+"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 patterns_exports = {};
+__export(patterns_exports, {
+  isEmail: () => isEmail,
+  mailPattern: () => mailPattern,
+  numberPattern: () => numberPattern
+});
+module.exports = __toCommonJS(patterns_exports);
+const numberPattern = /^[+-]?(?:\d*\.?\d+|\d+\.?\d*|0[bB][01]+|0[xX][\da-fA-F]+|0[oO][0-7]+)$/u;
+const mailPattern = /^(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-zA-Z0-9-]*[a-zA-Z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/u;
+function isEmail(value) {
+  return mailPattern.test(value);
 }

package/utils/periodic-reporter.js

@@ -1,65 +1,87 @@
-import { Subject } from 'rxjs';
-import { DeferredPromise } from '../promise/deferred-promise.js';
-import { CancellationToken } from './cancellation-token.js';
-import { cancelableTimeout } from './timing.js';
-export class PeriodicReporter {
-    reportSubject;
-    interval;
-    ignoreZero;
-    resetAfterReport;
-    stopToken;
-    stopped;
-    running;
-    counter;
-    stopRequested;
-    get report() {
-        return this.reportSubject.asObservable();
+"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 periodic_reporter_exports = {};
+__export(periodic_reporter_exports, {
+  PeriodicReporter: () => PeriodicReporter
+});
+module.exports = __toCommonJS(periodic_reporter_exports);
+var import_rxjs = require("rxjs");
+var import_deferred_promise = require("../promise/deferred-promise.js");
+var import_cancellation_token = require("./cancellation-token.js");
+var import_timing = require("./timing.js");
+class PeriodicReporter {
+  reportSubject;
+  interval;
+  ignoreZero;
+  resetAfterReport;
+  stopToken;
+  stopped;
+  running;
+  counter;
+  stopRequested;
+  get report() {
+    return this.reportSubject.asObservable();
+  }
+  constructor(interval, ignoreZero, resetAfterReport) {
+    this.interval = interval;
+    this.ignoreZero = ignoreZero;
+    this.resetAfterReport = resetAfterReport;
+    this.running = false;
+    this.stopToken = new import_cancellation_token.CancellationToken();
+    this.stopped = new import_deferred_promise.DeferredPromise();
+    this.reportSubject = new import_rxjs.Subject();
+  }
+  increase(count) {
+    this.counter += count;
+  }
+  run() {
+    if (this.running) {
+      throw new Error("already started");
     }
-    constructor(interval, ignoreZero, resetAfterReport) {
-        this.interval = interval;
-        this.ignoreZero = ignoreZero;
-        this.resetAfterReport = resetAfterReport;
-        this.running = false;
-        this.stopToken = new CancellationToken();
-        this.stopped = new DeferredPromise();
-        this.reportSubject = new Subject();
-    }
-    increase(count) {
-        this.counter += count;
-    }
-    run() {
-        if (this.running) {
-            throw new Error('already started');
+    this.running = true;
+    (async () => {
+      this.counter = 0;
+      this.stopRequested = false;
+      this.stopToken.unset();
+      this.stopped.reset();
+      while (!this.stopRequested) {
+        await (0, import_timing.cancelableTimeout)(this.interval, this.stopToken);
+        if (!this.stopRequested && (!this.ignoreZero || this.counter > 0)) {
+          this.emitReport(this.resetAfterReport);
         }
-        this.running = true;
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        (async () => {
-            this.counter = 0;
-            this.stopRequested = false;
-            this.stopToken.unset();
-            this.stopped.reset();
-            while (!this.stopRequested) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                await cancelableTimeout(this.interval, this.stopToken);
-                if (!this.stopRequested && (!this.ignoreZero || (this.counter > 0))) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                    this.emitReport(this.resetAfterReport);
-                }
-            }
-            this.running = false;
-            this.stopped.resolve();
-        })();
+      }
+      this.running = false;
+      this.stopped.resolve();
+    })();
+  }
+  async stop() {
+    if (!this.running) {
+      return;
     }
-    async stop() {
-        if (!this.running) {
-            return;
-        }
-        this.stopRequested = true;
-        this.stopToken.set();
-        await this.stopped;
-    }
-    emitReport(resetAfterReport) {
-        this.reportSubject.next(this.counter);
-        if (resetAfterReport) {
-            this.counter = 0;
-        }
+    this.stopRequested = true;
+    this.stopToken.set();
+    await this.stopped;
+  }
+  emitReport(resetAfterReport) {
+    this.reportSubject.next(this.counter);
+    if (resetAfterReport) {
+      this.counter = 0;
     }
+  }
 }

package/utils/periodic-sampler.js

@@ -1,73 +1,97 @@
-import { Subject } from 'rxjs';
-import { bufferCount, filter, map } from 'rxjs';
-import { compareByValue } from './comparison.js';
-import { average } from './math.js';
-import { timeout } from './timing.js';
-export var AggregationMode;
-(function (AggregationMode) {
-    AggregationMode[AggregationMode["Minimum"] = 0] = "Minimum";
-    AggregationMode[AggregationMode["Maximum"] = 1] = "Maximum";
-    AggregationMode[AggregationMode["Mean"] = 2] = "Mean";
-    AggregationMode[AggregationMode["Median"] = 3] = "Median";
-    AggregationMode[AggregationMode["FirstQuartile"] = 4] = "FirstQuartile";
-    AggregationMode[AggregationMode["ThirdQuartile"] = 5] = "ThirdQuartile";
+"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 periodic_sampler_exports = {};
+__export(periodic_sampler_exports, {
+  AggregationMode: () => AggregationMode,
+  PeriodicSampler: () => PeriodicSampler
+});
+module.exports = __toCommonJS(periodic_sampler_exports);
+var import_rxjs = require("rxjs");
+var import_rxjs2 = require("rxjs");
+var import_comparison = require("./comparison.js");
+var import_math = require("./math.js");
+var import_timing = require("./timing.js");
+var AggregationMode;
+(function(AggregationMode2) {
+  AggregationMode2[AggregationMode2["Minimum"] = 0] = "Minimum";
+  AggregationMode2[AggregationMode2["Maximum"] = 1] = "Maximum";
+  AggregationMode2[AggregationMode2["Mean"] = 2] = "Mean";
+  AggregationMode2[AggregationMode2["Median"] = 3] = "Median";
+  AggregationMode2[AggregationMode2["FirstQuartile"] = 4] = "FirstQuartile";
+  AggregationMode2[AggregationMode2["ThirdQuartile"] = 5] = "ThirdQuartile";
 })(AggregationMode || (AggregationMode = {}));
-export class PeriodicSampler {
-    sampleFunction;
-    subject;
-    run;
-    stopped;
-    sampleInterval;
-    constructor(sampleFunction, sampleInterval = 100) {
-        this.sampleFunction = sampleFunction;
-        this.sampleInterval = sampleInterval;
-        this.run = false;
-        this.subject = new Subject();
+class PeriodicSampler {
+  sampleFunction;
+  subject;
+  run;
+  stopped;
+  sampleInterval;
+  constructor(sampleFunction, sampleInterval = 100) {
+    this.sampleFunction = sampleFunction;
+    this.sampleInterval = sampleInterval;
+    this.run = false;
+    this.subject = new import_rxjs.Subject();
+  }
+  start() {
+    if (this.run) {
+      throw new Error("already started");
     }
-    start() {
-        if (this.run) {
-            throw new Error('already started');
-        }
-        this.run = true;
-        this.stopped = this.runSampleLoop();
-    }
-    async stop() {
-        this.run = false;
-        await this.stopped;
-    }
-    watch(threshold = 0, samples = 1, aggregation = AggregationMode.Maximum) {
-        const observable = this.subject.pipe(bufferCount(samples), map((measures) => aggregate(aggregation, measures)), filter((ms) => ms >= threshold));
-        return observable;
-    }
-    async runSampleLoop() {
-        while (this.run) {
-            const delay = await this.sampleFunction();
-            this.subject.next(delay);
-            await timeout(this.sampleInterval);
-        }
+    this.run = true;
+    this.stopped = this.runSampleLoop();
+  }
+  async stop() {
+    this.run = false;
+    await this.stopped;
+  }
+  watch(threshold = 0, samples = 1, aggregation = AggregationMode.Maximum) {
+    const observable = this.subject.pipe((0, import_rxjs2.bufferCount)(samples), (0, import_rxjs2.map)((measures) => aggregate(aggregation, measures)), (0, import_rxjs2.filter)((ms) => ms >= threshold));
+    return observable;
+  }
+  async runSampleLoop() {
+    while (this.run) {
+      const delay = await this.sampleFunction();
+      this.subject.next(delay);
+      await (0, import_timing.timeout)(this.sampleInterval);
     }
+  }
 }
 function aggregate(aggregation, values) {
-    switch (aggregation) {
-        case AggregationMode.Minimum:
-            return Math.min(...values);
-        case AggregationMode.Maximum:
-            return Math.max(...values);
-        case AggregationMode.Mean:
-            return average(values);
-        case AggregationMode.Median:
-            values.sort(compareByValue);
-            const median = Math.floor(values.length / 2);
-            return values[median];
-        case AggregationMode.FirstQuartile:
-            values.sort(compareByValue);
-            const firstQuartile = Math.floor(values.length / 4 * 1);
-            return values[firstQuartile];
-        case AggregationMode.ThirdQuartile:
-            values.sort(compareByValue);
-            const thirdQuartile = Math.floor(values.length / 4 * 3);
-            return values[thirdQuartile];
-        default:
-            throw new Error(`aggregation mode ${aggregation} not implemented`);
-    }
+  switch (aggregation) {
+    case AggregationMode.Minimum:
+      return Math.min(...values);
+    case AggregationMode.Maximum:
+      return Math.max(...values);
+    case AggregationMode.Mean:
+      return (0, import_math.average)(values);
+    case AggregationMode.Median:
+      values.sort(import_comparison.compareByValue);
+      const median = Math.floor(values.length / 2);
+      return values[median];
+    case AggregationMode.FirstQuartile:
+      values.sort(import_comparison.compareByValue);
+      const firstQuartile = Math.floor(values.length / 4 * 1);
+      return values[firstQuartile];
+    case AggregationMode.ThirdQuartile:
+      values.sort(import_comparison.compareByValue);
+      const thirdQuartile = Math.floor(values.length / 4 * 3);
+      return values[thirdQuartile];
+    default:
+      throw new Error(`aggregation mode ${aggregation} not implemented`);
+  }
 }

package/utils/provider-function-iterable.js

@@ -1,28 +1,50 @@
-import { timeout } from './timing.js';
-export class ProviderFunctionIterable {
-    providerFunction;
-    delay;
-    stopped;
-    constructor(providerFunction, delay) {
-        this.providerFunction = providerFunction;
-        this.delay = delay;
-        this.stopped = false;
-    }
-    stop() {
-        this.stopped = true;
-    }
-    async *[Symbol.asyncIterator]() {
-        while (!this.stopped) {
-            let result = this.providerFunction();
-            if (result instanceof Promise) {
-                result = await result;
-            }
-            if (result.hasItem) {
-                yield result.item;
-            }
-            else {
-                await timeout(this.delay);
-            }
-        }
+"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 provider_function_iterable_exports = {};
+__export(provider_function_iterable_exports, {
+  ProviderFunctionIterable: () => ProviderFunctionIterable
+});
+module.exports = __toCommonJS(provider_function_iterable_exports);
+var import_timing = require("./timing.js");
+class ProviderFunctionIterable {
+  providerFunction;
+  delay;
+  stopped;
+  constructor(providerFunction, delay) {
+    this.providerFunction = providerFunction;
+    this.delay = delay;
+    this.stopped = false;
+  }
+  stop() {
+    this.stopped = true;
+  }
+  async *[Symbol.asyncIterator]() {
+    while (!this.stopped) {
+      let result = this.providerFunction();
+      if (result instanceof Promise) {
+        result = await result;
+      }
+      if (result.hasItem) {
+        yield result.item;
+      } else {
+        await (0, import_timing.timeout)(this.delay);
+      }
     }
+  }
 }