@superutils/rx 0.1.17 → 0.1.18

package/dist/index.cjs

@@ -241,7 +241,7 @@ var IntervalRunner = class {
     this.sequential = sequential;
     this.preExecute = preExecute;
     this.minIntervalMs = 1e3;
-    this.runCount = 0;
+    this._runCount = 0;
     this.started = false;
     this.clearInterval = () => {
       this.sequential ? clearTimeout(this.idInterval) : clearInterval(this.idInterval);
@@ -253,16 +253,18 @@ var IntervalRunner = class {
       let result;
       if (this.sequential || once) this.clearInterval();
       try {
-        ++this.runCount;
-        await ((_a = this.onBeforeExec) == null ? void 0 : _a.call(this, this.runCount, once));
-        result = await this.taskFn.apply(void 0, this.taskArgs);
+        ++this._runCount;
+        await ((_a = this.onBeforeExec) == null ? void 0 : _a.call(this, this._runCount, once));
+        result = await this.taskFn(
+          ...(0, import_core5.isFn)(this.taskArgs) ? this.taskArgs.call(this, this._runCount) : this.taskArgs
+        );
         this.lastResult = result;
       } catch (_err) {
         err = _err;
       }
       (0, import_core5.fallbackIfFails)(
         this.onResult,
-        [err != null ? err : null, result, this.runCount, once],
+        [err != null ? err : null, result, this._runCount, once],
         void 0
       );
       if (!once && this.sequential && this.intervalMs$.value > this.minIntervalMs) {
@@ -273,7 +275,7 @@ var IntervalRunner = class {
       }
       return this.lastResult;
     };
-    /** Execute the task function regardless of the interval runner state */
+    /** Executes the task function once, regardless of the interval runner's current state. */
     this.executeOnce = async () => await this.executeTask(true);
     /** Check if interval is running*/
     this.isStarted = () => this.started;
@@ -291,18 +293,19 @@ var IntervalRunner = class {
       return true;
     };
     /**
-     * @summary set `onResult` & `onBeforeExec` callbacks and start execution.
-     *
-     * If it's already running, the callbacks will be used on the next execution.
+     * Sets the `onResult` and `onBeforeExec` callbacks and starts the interval execution.
      *
+     * If the runner is already started, the new callbacks will be used for subsequent executions.
+     * To apply new callbacks immediately, call `stop()` first, then `start()`.
      * In order to start using callbacks immediately, invoke the `intervalRunner.stop()` function first.
      *
+     * @param onResult (optional) function to be invoked whenever the task is succefully executed. See {@link OnResultType}
+     *
      * @returns {Boolean} indicates whether starting interveral waa successful
      */
     this.start = (onResult, onBeforeExec) => {
-      if (!onResult) return false;
-      this.onResult = onResult;
-      this.onBeforeExec = onBeforeExec;
+      if (onResult) this.onResult = onResult;
+      if (onBeforeExec) this.onBeforeExec = onBeforeExec;
       if (this.started) return false;
       this.started = true;
       let delayMs;
@@ -324,7 +327,7 @@ var IntervalRunner = class {
      */
     this.stop = (resetRunCount = false) => {
       var _a, _b;
-      if (resetRunCount) this.runCount = 0;
+      if (resetRunCount) this._runCount = 0;
       this.started = false;
       (_b = (_a = this.subscription) == null ? void 0 : _a.unsubscribe) == null ? void 0 : _b.call(_a);
       this.clearInterval();
@@ -332,6 +335,10 @@ var IntervalRunner = class {
     };
     this.intervalMs$ = intervalMs instanceof import_rxjs5.BehaviorSubject ? intervalMs : new import_rxjs5.BehaviorSubject(intervalMs);
   }
+  /** Get number of times task has ran, excluding resets */
+  get runCount() {
+    return this._runCount;
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.d.cts

@@ -178,7 +178,7 @@ output: Observable<TOut>) => ValueOrPromise<TOut> | typeof IGNORE_UPDATE_SYMBOL;
  * )
  * ```
  */
-declare function copyRx<TOut, Source$ extends Observable<any> | unknown[] = Observable<any> | unknown[], TIn = UnwrapSourceValueStrict<Source$>, Copy$ extends BehaviorSubject<TOut> | Subject<TOut> = BehaviorSubject<TOut>, ThisArg = unknown>(source$: Source$, transform?: CopyRx_Transform<TIn, TOut, ThisArg> | null, options?: CopyRx_Options<TOut, ThisArg>): Copy$;
+declare function copyRx<TOut, Source$ extends Observable<any> | unknown[] = Observable<any> | unknown[], TIn = UnwrapSourceValueStrict<Source$>, Copy$ extends BehaviorSubject<TOut> | Subject<TOut> = BehaviorSubject<TOut>, ThisArg = unknown>(source$: Source$, transform?: null | CopyRx_Transform<TIn, TOut, ThisArg>, options?: CopyRx_Options<TOut, ThisArg>): Copy$;
 declare function copyRx<TOut, Source$ extends Observable<any> | unknown[] = Observable<any> | unknown[], TIn = UnwrapSourceValueStrict<Source$>, Copy$ extends BehaviorSubject<TOut> | Subject<TOut> = BehaviorSubject<TOut>, ThisArg = unknown>(source$: Source$, transform: CopyRx_Transform<TIn, TOut, ThisArg>, options?: CopyRx_Options<TOut, ThisArg>): Copy$;
 declare namespace copyRx {
     var defaults: Required<Omit<DeferredOptions<unknown>, "thisArg"> & {
@@ -236,23 +236,37 @@ declare class IntervalSubject extends BehaviorSubject<number> {
     stop: () => this;
 }
 
+/**
+ * `onResult` callback signature for {@link IntervalRunner}
+ *
+ * @param error
+ * @param result
+ * @param runCount number times the task has been executed
+ * @param once: if the task was executed outside of interval setup using `instance.executeOnce()` function.
+ */
 type OnResultType<TResult = unknown> = (error: Error | null, result: TResult | undefined, runCount: number, once: boolean) => void | Promise<void>;
-type onBeforeExecType = (runCount: number, once: boolean) => void | Promise<unknown>;
 /**
- * @summary	a simple runner to execute a task periodically.
+ * `onBeforeExecType` callback signature for {@link IntervalRunner}
+ *
+ * @param runCount number times the task has been executed
+ * @param once: if the task was executed outside of interval setup using `instance.executeOnce()` function.
+ */
+type onBeforeExecType = (runCount: number, once: boolean) => void | Promise<void>;
+/**
+ * A simple runner to execute a task periodically.
  *
  * When to use `IntervalRunner` instead of `IntervalSubject`?
  *
- * `IntervalRunner` is useful when the execution of the `onResult` time must be on the clock and/or must be excluded
- * from the interval delay duration.
+ * `IntervalRunner` is useful when the execution of the `taskFn` (and its `onResult` callback)
+ * needs to be precisely timed and/or excluded from the interval delay duration.
  *
- * Example use case:
+ * @example
  * When an API call needs to be made periodically and there's a possibility of delayed response (due to network issues
  * or longer backend execution time). In this case, using IntervalRunner with `sequential = true` will ensure the
  * delay is consistent between completion of current and start of the next API call.
  *
  * @param	taskFn		task function to be executed periodically
- * @param	taskArgs	arguments to be supplied to the task function.
+ * @param	taskArgs	arguments (or a function that returns arguments) to be supplied to the task function.
  * @param	intervalMs	timer delay in milliseconds.
  * @param	sequential	true (default): will use setTimeout and will delay until execution is completed.
  * This will ensure, in case the current execution takes longer, the following execution will not occur until current one is done and the interval delay is passed.
@@ -267,28 +281,29 @@ type onBeforeExecType = (runCount: number, once: boolean) => void | Promise<unkn
  *
  * @example
  * #### Execute a function sequentially
- * Counting time will not start until function execution ends, maintaining the delay betweeen
+ * Counting time will not start until function execution ends, maintaining the delay between
  * end of execution consistent.
- * ```typescript
+ * ```javascript
  * import fetch from '@superutils/fetch'
- * import { IntervalRunner } fro '@superutils/rx'
+ * import { IntervalRunner } from '@superutils/rx'
  *
  * const runner = new IntervalRunner(
- *     fetch.get,
- * 	   ['[DUMMYJSON-DOT-COM]/products'],
+ *     fetch.get, // function to execute
+ * 	   ['[DUMMYJSON-DOT-COM]/products'], // arguments to be provided to the function on each execution
  *     2000,
  *  )
  * runner.start(result => console.log({ result }))
  * ```
  *
  * @example
- * #### Execute a function at without enforcing sequential execution.
- * Will start counting time even if function execution is unfinied, maintaining the delay betweeen
- * start of execution consistent.
- * ```typescript
+ * #### Execute a function without enforcing sequential completion
+ * Timing begins at the start of the task, ensuring a consistent interval between the **start**
+ * of each execution, regardless of when the task finishes.
+ * ```javascript
  * import fetch from '@superutils/fetch'
- * import { IntervalRunner } fro '@superutils/rx'
+ * import { IntervalRunner } from '@superutils/rx'
  *
+ * // Create a interval runner that retrieves products every 2 seconds
  * const runner = new IntervalRunner(
  *   fetch.get,
  * 	 ['[DUMMYJSON-DOT-COM]/products'],
@@ -297,10 +312,27 @@ type onBeforeExecType = (runCount: number, once: boolean) => void | Promise<unkn
  *  )
  * runner.start(result => console.log({ result }))
  * ```
+ *
+ * @example
+ * #### Execute a function and auto-retry on failure
+ * ```javascript
+ * import fetch from '@superutils/fetch'
+ * import { IntervalRunner } from '@superutils/rx'
+ *
+ * const runner = new IntervalRunner(
+ *   () => retry(
+ *     fetch.get, // function to execute
+ *     { retry: 3 }, // retry maximum 3 times (max 5 attempts )
+ *   ),
+ * 	 ['[DUMMYJSON-DOT-COM]/products'], // arguments to be provided to the function on each execution
+ *   2000,
+ *  )
+ * runner.start(result => console.log({ result }))
+ * ```
  */
 declare class IntervalRunner<TResult = unknown, TArgs extends unknown[] = unknown[]> {
     readonly taskFn: (...args: TArgs) => TResult | Promise<TResult>;
-    readonly taskArgs: TArgs;
+    readonly taskArgs: TArgs | ((this: IntervalRunner<TResult, TArgs>, runCount: number) => TArgs);
     readonly sequential: boolean;
     readonly preExecute: boolean;
     private idInterval;
@@ -309,17 +341,17 @@ declare class IntervalRunner<TResult = unknown, TArgs extends unknown[] = unknow
     private onBeforeExec?;
     private onResult;
     /**
-     * @summary RxJS BehaviorSubject to change timer delay and restart the timer
+     * RxJS BehaviorSubject to change timer delay (and restart the timer) on the fly
      */
     readonly intervalMs$: BehaviorSubject<number>;
-    private runCount;
+    private _runCount;
     private started;
     private subscription;
-    constructor(taskFn: (...args: TArgs) => TResult | Promise<TResult>, taskArgs: TArgs, intervalMs: BehaviorSubject<number> | number, sequential?: boolean, // if true, timer will start start only after execution is finished
+    constructor(taskFn: (...args: TArgs) => TResult | Promise<TResult>, taskArgs: TArgs | ((this: IntervalRunner<TResult, TArgs>, runCount: number) => TArgs), intervalMs: BehaviorSubject<number> | number, sequential?: boolean, // If true, timer will start only after execution is finished.
     preExecute?: boolean);
     private clearInterval;
     private executeTask;
-    /** Execute the task function regardless of the interval runner state */
+    /** Executes the task function once, regardless of the interval runner's current state. */
     executeOnce: () => Promise<TResult | undefined>;
     /** Check if interval is running*/
     isStarted: () => boolean;
@@ -331,16 +363,20 @@ declare class IntervalRunner<TResult = unknown, TArgs extends unknown[] = unknow
      * @returns {Boolean} indicates whether restart was successful
      */
     restart: (resetRunCount?: boolean) => boolean;
+    /** Get number of times task has ran, excluding resets */
+    get runCount(): number;
     /**
-     * @summary set `onResult` & `onBeforeExec` callbacks and start execution.
-     *
-     * If it's already running, the callbacks will be used on the next execution.
+     * Sets the `onResult` and `onBeforeExec` callbacks and starts the interval execution.
      *
+     * If the runner is already started, the new callbacks will be used for subsequent executions.
+     * To apply new callbacks immediately, call `stop()` first, then `start()`.
      * In order to start using callbacks immediately, invoke the `intervalRunner.stop()` function first.
      *
+     * @param onResult (optional) function to be invoked whenever the task is succefully executed. See {@link OnResultType}
+     *
      * @returns {Boolean} indicates whether starting interveral waa successful
      */
-    start: (onResult: OnResultType<TResult>, onBeforeExec?: onBeforeExecType) => boolean;
+    start: (onResult?: OnResultType<TResult>, onBeforeExec?: onBeforeExecType) => boolean;
     /**
      * Stop interval runner
      *

package/dist/index.d.ts

@@ -178,7 +178,7 @@ output: Observable<TOut>) => ValueOrPromise<TOut> | typeof IGNORE_UPDATE_SYMBOL;
  * )
  * ```
  */
-declare function copyRx<TOut, Source$ extends Observable<any> | unknown[] = Observable<any> | unknown[], TIn = UnwrapSourceValueStrict<Source$>, Copy$ extends BehaviorSubject<TOut> | Subject<TOut> = BehaviorSubject<TOut>, ThisArg = unknown>(source$: Source$, transform?: CopyRx_Transform<TIn, TOut, ThisArg> | null, options?: CopyRx_Options<TOut, ThisArg>): Copy$;
+declare function copyRx<TOut, Source$ extends Observable<any> | unknown[] = Observable<any> | unknown[], TIn = UnwrapSourceValueStrict<Source$>, Copy$ extends BehaviorSubject<TOut> | Subject<TOut> = BehaviorSubject<TOut>, ThisArg = unknown>(source$: Source$, transform?: null | CopyRx_Transform<TIn, TOut, ThisArg>, options?: CopyRx_Options<TOut, ThisArg>): Copy$;
 declare function copyRx<TOut, Source$ extends Observable<any> | unknown[] = Observable<any> | unknown[], TIn = UnwrapSourceValueStrict<Source$>, Copy$ extends BehaviorSubject<TOut> | Subject<TOut> = BehaviorSubject<TOut>, ThisArg = unknown>(source$: Source$, transform: CopyRx_Transform<TIn, TOut, ThisArg>, options?: CopyRx_Options<TOut, ThisArg>): Copy$;
 declare namespace copyRx {
     var defaults: Required<Omit<DeferredOptions<unknown>, "thisArg"> & {
@@ -236,23 +236,37 @@ declare class IntervalSubject extends BehaviorSubject<number> {
     stop: () => this;
 }
 
+/**
+ * `onResult` callback signature for {@link IntervalRunner}
+ *
+ * @param error
+ * @param result
+ * @param runCount number times the task has been executed
+ * @param once: if the task was executed outside of interval setup using `instance.executeOnce()` function.
+ */
 type OnResultType<TResult = unknown> = (error: Error | null, result: TResult | undefined, runCount: number, once: boolean) => void | Promise<void>;
-type onBeforeExecType = (runCount: number, once: boolean) => void | Promise<unknown>;
 /**
- * @summary	a simple runner to execute a task periodically.
+ * `onBeforeExecType` callback signature for {@link IntervalRunner}
+ *
+ * @param runCount number times the task has been executed
+ * @param once: if the task was executed outside of interval setup using `instance.executeOnce()` function.
+ */
+type onBeforeExecType = (runCount: number, once: boolean) => void | Promise<void>;
+/**
+ * A simple runner to execute a task periodically.
  *
  * When to use `IntervalRunner` instead of `IntervalSubject`?
  *
- * `IntervalRunner` is useful when the execution of the `onResult` time must be on the clock and/or must be excluded
- * from the interval delay duration.
+ * `IntervalRunner` is useful when the execution of the `taskFn` (and its `onResult` callback)
+ * needs to be precisely timed and/or excluded from the interval delay duration.
  *
- * Example use case:
+ * @example
  * When an API call needs to be made periodically and there's a possibility of delayed response (due to network issues
  * or longer backend execution time). In this case, using IntervalRunner with `sequential = true` will ensure the
  * delay is consistent between completion of current and start of the next API call.
  *
  * @param	taskFn		task function to be executed periodically
- * @param	taskArgs	arguments to be supplied to the task function.
+ * @param	taskArgs	arguments (or a function that returns arguments) to be supplied to the task function.
  * @param	intervalMs	timer delay in milliseconds.
  * @param	sequential	true (default): will use setTimeout and will delay until execution is completed.
  * This will ensure, in case the current execution takes longer, the following execution will not occur until current one is done and the interval delay is passed.
@@ -267,28 +281,29 @@ type onBeforeExecType = (runCount: number, once: boolean) => void | Promise<unkn
  *
  * @example
  * #### Execute a function sequentially
- * Counting time will not start until function execution ends, maintaining the delay betweeen
+ * Counting time will not start until function execution ends, maintaining the delay between
  * end of execution consistent.
- * ```typescript
+ * ```javascript
  * import fetch from '@superutils/fetch'
- * import { IntervalRunner } fro '@superutils/rx'
+ * import { IntervalRunner } from '@superutils/rx'
  *
  * const runner = new IntervalRunner(
- *     fetch.get,
- * 	   ['[DUMMYJSON-DOT-COM]/products'],
+ *     fetch.get, // function to execute
+ * 	   ['[DUMMYJSON-DOT-COM]/products'], // arguments to be provided to the function on each execution
  *     2000,
  *  )
  * runner.start(result => console.log({ result }))
  * ```
  *
  * @example
- * #### Execute a function at without enforcing sequential execution.
- * Will start counting time even if function execution is unfinied, maintaining the delay betweeen
- * start of execution consistent.
- * ```typescript
+ * #### Execute a function without enforcing sequential completion
+ * Timing begins at the start of the task, ensuring a consistent interval between the **start**
+ * of each execution, regardless of when the task finishes.
+ * ```javascript
  * import fetch from '@superutils/fetch'
- * import { IntervalRunner } fro '@superutils/rx'
+ * import { IntervalRunner } from '@superutils/rx'
  *
+ * // Create a interval runner that retrieves products every 2 seconds
  * const runner = new IntervalRunner(
  *   fetch.get,
  * 	 ['[DUMMYJSON-DOT-COM]/products'],
@@ -297,10 +312,27 @@ type onBeforeExecType = (runCount: number, once: boolean) => void | Promise<unkn
  *  )
  * runner.start(result => console.log({ result }))
  * ```
+ *
+ * @example
+ * #### Execute a function and auto-retry on failure
+ * ```javascript
+ * import fetch from '@superutils/fetch'
+ * import { IntervalRunner } from '@superutils/rx'
+ *
+ * const runner = new IntervalRunner(
+ *   () => retry(
+ *     fetch.get, // function to execute
+ *     { retry: 3 }, // retry maximum 3 times (max 5 attempts )
+ *   ),
+ * 	 ['[DUMMYJSON-DOT-COM]/products'], // arguments to be provided to the function on each execution
+ *   2000,
+ *  )
+ * runner.start(result => console.log({ result }))
+ * ```
  */
 declare class IntervalRunner<TResult = unknown, TArgs extends unknown[] = unknown[]> {
     readonly taskFn: (...args: TArgs) => TResult | Promise<TResult>;
-    readonly taskArgs: TArgs;
+    readonly taskArgs: TArgs | ((this: IntervalRunner<TResult, TArgs>, runCount: number) => TArgs);
     readonly sequential: boolean;
     readonly preExecute: boolean;
     private idInterval;
@@ -309,17 +341,17 @@ declare class IntervalRunner<TResult = unknown, TArgs extends unknown[] = unknow
     private onBeforeExec?;
     private onResult;
     /**
-     * @summary RxJS BehaviorSubject to change timer delay and restart the timer
+     * RxJS BehaviorSubject to change timer delay (and restart the timer) on the fly
      */
     readonly intervalMs$: BehaviorSubject<number>;
-    private runCount;
+    private _runCount;
     private started;
     private subscription;
-    constructor(taskFn: (...args: TArgs) => TResult | Promise<TResult>, taskArgs: TArgs, intervalMs: BehaviorSubject<number> | number, sequential?: boolean, // if true, timer will start start only after execution is finished
+    constructor(taskFn: (...args: TArgs) => TResult | Promise<TResult>, taskArgs: TArgs | ((this: IntervalRunner<TResult, TArgs>, runCount: number) => TArgs), intervalMs: BehaviorSubject<number> | number, sequential?: boolean, // If true, timer will start only after execution is finished.
     preExecute?: boolean);
     private clearInterval;
     private executeTask;
-    /** Execute the task function regardless of the interval runner state */
+    /** Executes the task function once, regardless of the interval runner's current state. */
     executeOnce: () => Promise<TResult | undefined>;
     /** Check if interval is running*/
     isStarted: () => boolean;
@@ -331,16 +363,20 @@ declare class IntervalRunner<TResult = unknown, TArgs extends unknown[] = unknow
      * @returns {Boolean} indicates whether restart was successful
      */
     restart: (resetRunCount?: boolean) => boolean;
+    /** Get number of times task has ran, excluding resets */
+    get runCount(): number;
     /**
-     * @summary set `onResult` & `onBeforeExec` callbacks and start execution.
-     *
-     * If it's already running, the callbacks will be used on the next execution.
+     * Sets the `onResult` and `onBeforeExec` callbacks and starts the interval execution.
      *
+     * If the runner is already started, the new callbacks will be used for subsequent executions.
+     * To apply new callbacks immediately, call `stop()` first, then `start()`.
      * In order to start using callbacks immediately, invoke the `intervalRunner.stop()` function first.
      *
+     * @param onResult (optional) function to be invoked whenever the task is succefully executed. See {@link OnResultType}
+     *
      * @returns {Boolean} indicates whether starting interveral waa successful
      */
-    start: (onResult: OnResultType<TResult>, onBeforeExec?: onBeforeExecType) => boolean;
+    start: (onResult?: OnResultType<TResult>, onBeforeExec?: onBeforeExecType) => boolean;
     /**
      * Stop interval runner
      *

package/dist/index.js

@@ -211,7 +211,7 @@ var IntervalSubject = class extends BehaviorSubject2 {
 };
 
 // src/IntervalRunner.ts
-import { fallbackIfFails as fallbackIfFails3, noop } from "@superutils/core";
+import { fallbackIfFails as fallbackIfFails3, isFn as isFn5, noop } from "@superutils/core";
 import { BehaviorSubject as BehaviorSubject3 } from "rxjs";
 var IntervalRunner = class {
   constructor(taskFn, taskArgs, intervalMs, sequential = true, preExecute = true) {
@@ -220,7 +220,7 @@ var IntervalRunner = class {
     this.sequential = sequential;
     this.preExecute = preExecute;
     this.minIntervalMs = 1e3;
-    this.runCount = 0;
+    this._runCount = 0;
     this.started = false;
     this.clearInterval = () => {
       this.sequential ? clearTimeout(this.idInterval) : clearInterval(this.idInterval);
@@ -232,16 +232,18 @@ var IntervalRunner = class {
       let result;
       if (this.sequential || once) this.clearInterval();
       try {
-        ++this.runCount;
-        await ((_a = this.onBeforeExec) == null ? void 0 : _a.call(this, this.runCount, once));
-        result = await this.taskFn.apply(void 0, this.taskArgs);
+        ++this._runCount;
+        await ((_a = this.onBeforeExec) == null ? void 0 : _a.call(this, this._runCount, once));
+        result = await this.taskFn(
+          ...isFn5(this.taskArgs) ? this.taskArgs.call(this, this._runCount) : this.taskArgs
+        );
         this.lastResult = result;
       } catch (_err) {
         err = _err;
       }
       fallbackIfFails3(
         this.onResult,
-        [err != null ? err : null, result, this.runCount, once],
+        [err != null ? err : null, result, this._runCount, once],
         void 0
       );
       if (!once && this.sequential && this.intervalMs$.value > this.minIntervalMs) {
@@ -252,7 +254,7 @@ var IntervalRunner = class {
       }
       return this.lastResult;
     };
-    /** Execute the task function regardless of the interval runner state */
+    /** Executes the task function once, regardless of the interval runner's current state. */
     this.executeOnce = async () => await this.executeTask(true);
     /** Check if interval is running*/
     this.isStarted = () => this.started;
@@ -270,18 +272,19 @@ var IntervalRunner = class {
       return true;
     };
     /**
-     * @summary set `onResult` & `onBeforeExec` callbacks and start execution.
-     *
-     * If it's already running, the callbacks will be used on the next execution.
+     * Sets the `onResult` and `onBeforeExec` callbacks and starts the interval execution.
      *
+     * If the runner is already started, the new callbacks will be used for subsequent executions.
+     * To apply new callbacks immediately, call `stop()` first, then `start()`.
      * In order to start using callbacks immediately, invoke the `intervalRunner.stop()` function first.
      *
+     * @param onResult (optional) function to be invoked whenever the task is succefully executed. See {@link OnResultType}
+     *
      * @returns {Boolean} indicates whether starting interveral waa successful
      */
     this.start = (onResult, onBeforeExec) => {
-      if (!onResult) return false;
-      this.onResult = onResult;
-      this.onBeforeExec = onBeforeExec;
+      if (onResult) this.onResult = onResult;
+      if (onBeforeExec) this.onBeforeExec = onBeforeExec;
       if (this.started) return false;
       this.started = true;
       let delayMs;
@@ -303,7 +306,7 @@ var IntervalRunner = class {
      */
     this.stop = (resetRunCount = false) => {
       var _a, _b;
-      if (resetRunCount) this.runCount = 0;
+      if (resetRunCount) this._runCount = 0;
       this.started = false;
       (_b = (_a = this.subscription) == null ? void 0 : _a.unsubscribe) == null ? void 0 : _b.call(_a);
       this.clearInterval();
@@ -311,6 +314,10 @@ var IntervalRunner = class {
     };
     this.intervalMs$ = intervalMs instanceof BehaviorSubject3 ? intervalMs : new BehaviorSubject3(intervalMs);
   }
+  /** Get number of times task has ran, excluding resets */
+  get runCount() {
+    return this._runCount;
+  }
 };
 export {
   IGNORE_UPDATE_SYMBOL,

package/package.json

@@ -2,8 +2,8 @@
 	"author": "Toufiqur Rahaman Chowdhury",
 	"description": "A set of small, focused utilities for working with RxJS observables and subjects.",
 	"dependencies": {
-		"@superutils/core": "^1.2.21",
-		"@superutils/promise": "^1.3.20",
+		"@superutils/core": "^1.2.22",
+		"@superutils/promise": "^1.3.21",
 		"@types/react": "^18.0.0",
 		"react": ">=16.8.0",
 		"rxjs": "^7.8.2"
@@ -49,6 +49,6 @@
 	"module": "./dist/index.js",
 	"type": "module",
 	"types": "./dist/index.d.ts",
-	"version": "0.1.17",
-	"gitHead": "54a29f73ae09335819d591df271d9f57c92da457"
+	"version": "0.1.18",
+	"gitHead": "35722628393f7eface789fea15e80e521c509831"
 }