@creejs/commons-retrier 2.0.0 → 2.0.2

package/types/event.d.ts

@@ -1,9 +1,21 @@
 export const Start: "start";
+export const Stop: "stop";
 export const Retry: "retry";
 export const Success: "success";
 export const Failure: "failure";
 export const Timeout: "timeout";
 export const TaskTimeout: "task-timeout";
-export const Stop: "stop";
 export const Completed: "complete";
 export const MaxRetries: "max-retries";
+declare namespace _default {
+    export { Start };
+    export { Retry };
+    export { Success };
+    export { Failure };
+    export { Timeout };
+    export { TaskTimeout };
+    export { Stop };
+    export { Completed };
+    export { MaxRetries };
+}
+export default _default;

package/types/index.d.ts

@@ -1,25 +1,52 @@
-declare const _exports: {
-    name: typeof RetrierFactory.name;
-    infinite: typeof RetrierFactory.infinite;
-    times: typeof RetrierFactory.times;
-    maxRetries: typeof RetrierFactory.maxRetries;
-    min: typeof RetrierFactory.min;
-    max: typeof RetrierFactory.max;
-    range: typeof RetrierFactory.range;
-    fixedInterval: typeof RetrierFactory.fixedInterval;
-    fixedIncrease: typeof RetrierFactory.fixedIncrease;
-    factorIncrease: typeof RetrierFactory.factorIncrease;
-    shuttleInterval: typeof RetrierFactory.shuttleInterval;
-    timeout: typeof RetrierFactory.timeout;
-    taskTimeout: typeof RetrierFactory.taskTimeout;
-    start: typeof RetrierFactory.start;
+declare const _default: {
+    name: typeof import("./retrier-factory.js").name;
+    infinite: typeof import("./retrier-factory.js").infinite;
+    times: typeof import("./retrier-factory.js").times;
+    maxRetries: typeof import("./retrier-factory.js").maxRetries;
+    min: typeof import("./retrier-factory.js").min;
+    max: typeof import("./retrier-factory.js").max;
+    range: typeof import("./retrier-factory.js").range;
+    fixedInterval: typeof import("./retrier-factory.js").fixedInterval;
+    fixedIncrease: typeof import("./retrier-factory.js").fixedIncrease;
+    factorIncrease: typeof import("./retrier-factory.js").factorIncrease;
+    shuttleInterval: typeof import("./retrier-factory.js").shuttleInterval;
+    timeout: typeof import("./retrier-factory.js").timeout;
+    taskTimeout: typeof import("./retrier-factory.js").taskTimeout;
+    start: typeof import("./retrier-factory.js").start;
     Policy: typeof Policy;
     Retrier: typeof Retrier;
-    Event: typeof Event;
-    RetrierFactory: typeof RetrierFactory;
+    Event: {
+        Start: string;
+        Retry: string;
+        Success: string;
+        Failure: string;
+        Timeout: string;
+        TaskTimeout: string;
+        Stop: string;
+        Completed: string;
+        MaxRetries: string;
+    };
+    RetrierFactory: {
+        name: typeof import("./retrier-factory.js").name;
+        infinite: typeof import("./retrier-factory.js").infinite;
+        times: typeof import("./retrier-factory.js").times;
+        maxRetries: typeof import("./retrier-factory.js").maxRetries;
+        min: typeof import("./retrier-factory.js").min;
+        max: typeof import("./retrier-factory.js").max;
+        range: typeof import("./retrier-factory.js").range;
+        fixedInterval: typeof import("./retrier-factory.js").fixedInterval;
+        fixedIncrease: typeof import("./retrier-factory.js").fixedIncrease;
+        factorIncrease: typeof import("./retrier-factory.js").factorIncrease;
+        shuttleInterval: typeof import("./retrier-factory.js").shuttleInterval;
+        timeout: typeof import("./retrier-factory.js").timeout;
+        taskTimeout: typeof import("./retrier-factory.js").taskTimeout;
+        start: typeof import("./retrier-factory.js").start;
+    };
 };
-export = _exports;
-import RetrierFactory = require("./retrier-factory");
-import Policy = require("./policy");
-import Retrier = require("./retrier");
-import Event = require("./event");
+export default _default;
+export * from "./retrier-factory.js";
+import Policy from "./policy.js";
+import Retrier from "./retrier.js";
+import Event from "./event.js";
+import RetrierFactory from "./retrier-factory.js";
+export { Policy, Retrier, Event, RetrierFactory };

package/types/policy/factor-increase-policy.d.ts

@@ -1,12 +1,12 @@
-export = FactoreIncreasePolicy;
-declare class FactoreIncreasePolicy extends Policy {
+export default class FactoreIncreasePolicy extends Policy {
     /**
      * each call to _next() increases the interval by lastInterval * factor
      * @param {number} factor - the increasement factor, >= 1
      */
     constructor(factor: number);
     _factor: number;
-    set factor(factor: number);
+    set factor(arg: number);
     get factor(): number;
 }
-import Policy = require("../policy");
+export { FactoreIncreasePolicy as FactoreIncreasePolicyType };
+import Policy from "../policy.js";

package/types/policy/fixed-increase-policy.d.ts

@@ -1,12 +1,12 @@
-export = FixedIncreasePolicy;
-declare class FixedIncreasePolicy extends Policy {
+export default class FixedIncreasePolicy extends Policy {
     /**
      * each call to _next() increases the interval by "increasement".
      * @param {number} increasement - The fixed interval (in milliseconds) between retry attempts.
      */
     constructor(increasement: number);
     _increasement: number;
-    set increasement(increasement: number);
+    set increasement(arg: number);
     get increasement(): number;
 }
-import Policy = require("../policy");
+export { FixedIncreasePolicy as FixedIncreasePolicyType };
+import Policy from "../policy.js";

package/types/policy/fixed-interval-policy.d.ts

@@ -1,12 +1,12 @@
-export = FixedIntervalPolicy;
-declare class FixedIntervalPolicy extends Policy {
+export default class FixedIntervalPolicy extends Policy {
     /**
      * Creates a fixed interval retry policy with the specified interval.
      * @param {number} interval - The fixed interval (in milliseconds) between retry attempts.
      */
     constructor(interval: number);
     _interval: number;
-    set interval(interval: number);
+    set interval(arg: number);
     get interval(): number;
 }
-import Policy = require("../policy");
+export { FixedIntervalPolicy as FixedIntervalPolicyType };
+import Policy from "../policy.js";

package/types/policy/shuttle-policy.d.ts

@@ -1,5 +1,4 @@
-export = ShuttlePolicy;
-declare class ShuttlePolicy extends Policy {
+export default class ShuttlePolicy extends Policy {
     /**
      * the inteval value shuttles between min and max
      * @param {number} stepLength - the step length to change
@@ -7,7 +6,8 @@ declare class ShuttlePolicy extends Policy {
     constructor(stepLength: number);
     _stepLength: number;
     increasement: number;
-    set stepLength(stepLength: number);
+    set stepLength(arg: number);
     get stepLength(): number;
 }
-import Policy = require("../policy");
+export { ShuttlePolicy as ShuttlePolicyType };
+import Policy from "../policy.js";

package/types/policy.d.ts

@@ -1,5 +1,4 @@
-export = Policy;
-declare class Policy {
+export default class Policy {
     _min: number;
     _max: number;
     _nextInterval: number;
@@ -35,7 +34,7 @@ declare class Policy {
      * @returns {this} The retrier instance for chaining.
      */
     max(max: number): this;
-    reset(): this;
+    reset(): Policy;
     /**
      * Interval ms of next execution
      * @returns {number}
@@ -50,3 +49,4 @@ declare class Policy {
      */
     protected _next(): number;
 }
+export { Policy as PolicyType };

package/types/retrier-factory.d.ts

@@ -1,3 +1,20 @@
+declare namespace _default {
+    export { name };
+    export { infinite };
+    export { times };
+    export { maxRetries };
+    export { min };
+    export { max };
+    export { range };
+    export { fixedInterval };
+    export { fixedIncrease };
+    export { factorIncrease };
+    export { shuttleInterval };
+    export { timeout };
+    export { taskTimeout };
+    export { start };
+}
+export default _default;
 /**
  * Creates a new Retrier instance with the specified name.
  * @param {string} name - The name to assign to the retrier.
@@ -82,4 +99,4 @@ export function taskTimeout(timeout: number): Retrier;
  * @returns {Promise<*>} A promise that resolves when the retry process completes.
  */
 export function start(task: Function): Promise<any>;
-import Retrier = require("./retrier");
+import Retrier from "./retrier.js";

package/types/retrier.d.ts

@@ -1,13 +1,12 @@
-export = Retrier;
 /**
  * @extends EventEmitter
  */
-declare class Retrier {
+export default class Retrier {
     /**
      * Creates a new Retrier instance with a fixed interval policy.
      * @param {number} [fixedInterval=1000] - The fixed interval in milliseconds between retry attempts. Defaults to 1000ms if not provided.
      */
-    constructor(fixedInterval?: number);
+    constructor(fixedInterval?: number | undefined);
     /**
      * @type {Policy}
      */
@@ -153,7 +152,7 @@ declare class Retrier {
      * @param {boolean} [resetAfterSuccess=false] - Whether to reset retry counters after success.
      * @returns {this} The Retrier instance for chaining.
      */
-    always(task: Function, resetAfterSuccess?: boolean): this;
+    always(task: Function, resetAfterSuccess?: boolean | undefined): this;
     /**
      * Starts the retry process.
      * @returns {Promise<*>}
@@ -164,7 +163,7 @@ declare class Retrier {
      * @param {Error} [reason] - Optional reason for stopping (defaults to 'Manually Stop' error).
      * @returns {Promise<void>} A promise that resolves when the retrier has fully stopped.
      */
-    stop(reason?: Error): Promise<void>;
+    stop(reason?: Error | undefined): Promise<void>;
     /**
      * Resets the retry policy to its initial state.
      */
@@ -209,7 +208,7 @@ declare class Retrier {
      * Registers a listener for "timeout" events.
      * @param {Function} listener - The callback function
      */
-    onTimeout(listener: Function): this;
+    onTimeout(listener: Function): Retrier;
     /**
      * Registers a listener for "task-timeout" events.
      * @param {Function} listener - The callback function
@@ -220,7 +219,7 @@ declare class Retrier {
      * Registers a listener for "completed" events.
      * @param {Function} listener - The callback function
      */
-    onCompleted(listener: Function): this;
+    onCompleted(listener: Function): Retrier;
     /**
      * Registers a listener for the 'MaxRetries' event.
      * @param {Function} listener - The callback function to be executed when max retries are reached.
@@ -228,6 +227,7 @@ declare class Retrier {
      */
     onMaxRetries(listener: Function): this;
 }
-import Policy = require("./policy");
-import Task = require("./task");
-import AlwaysTask = require("./alway-task");
+export { Retrier as RetrierType };
+import Policy from "./policy.js";
+import Task from "./task.js";
+import AlwaysTask from "./alway-task.js";

package/types/task.d.ts

@@ -1,12 +1,11 @@
-export = Task;
-declare class Task {
+export default class Task {
     /**
      * Creates a new Task instance.
      * @param {Retrier} retrier - The retrier instance.
      * @param {Function} task - The function to be executed as the task.
      */
     constructor(retrier: Retrier, task: Function);
-    retrier: Retrier;
+    retrier: import("./retrier.js").default;
     task: Function;
     result: any;
     error: unknown;
@@ -25,4 +24,5 @@ declare class Task {
     execute(retries: number, latence: number, nextInterval: number): Promise<void>;
     dispose(): void;
 }
-import Retrier = require("./retrier");
+export { Task as TaskType };
+export type Retrier = import('./retrier.js').default;

package/lib/alway-task.js

@@ -1,44 +0,0 @@
-'use strict'
-
-// owned
-// eslint-disable-next-line no-unused-vars
-const Retrier = require('./retrier')
-const Task = require('./task')
-
-class AlwaysTask extends Task {
-  /**
-   * Checks if the given task is an instance of AlwaysTask.
-   * @param {*} task - The task to check.
-   * @returns {boolean} True if the task is an instance of AlwaysTask, false otherwise.
-   */
-  static isAlwaysTask (task) {
-    return task instanceof AlwaysTask
-  }
-
-  /**
-   * Creates an AlwaysTask instance.
-   * @param {Retrier} retrier - The retrier instance to use for retry logic
-   * @param {Function} task - The task function to execute
-   * @param {boolean} resetRetryPolicyAfterSuccess - Whether to reset retry policy after successful execution
-   */
-  constructor (retrier, task, resetRetryPolicyAfterSuccess) {
-    super(retrier, task)
-    this.resetPolicy = resetRetryPolicyAfterSuccess
-  }
-
-  /**
-   * Executes the task with the given retry parameters.
-   * @param {number} retries - The number of retries attempted so far.
-   * @param {number} latence - The current latency ms.
-   * @param {number} nextInterval - The next interval ms.
-   * @returns {Promise<*>} The result of the task execution.
-   */
-  async execute (retries, latence, nextInterval) {
-    await super.execute(retries, latence, nextInterval)
-    if (this.succeeded && this.resetPolicy) {
-      this.retrier.resetRetryPolicy()
-    }
-  }
-}
-
-module.exports = AlwaysTask

package/lib/constants.js

@@ -1,11 +0,0 @@
-'use strict'
-// module vars
-const DefaultMinInterval = 50
-const DefaultMaxInterval = 30 * 1000 // 30s
-
-const DefaultMaxRetries = 3
-module.exports = {
-  DefaultMinInterval,
-  DefaultMaxInterval,
-  DefaultMaxRetries
-}

package/lib/event.js

@@ -1,22 +0,0 @@
-'use strict'
-const Start = 'start' // retry started
-const Stop = 'stop' // retry stopped
-const Retry = 'retry' // one retry began
-const Success = 'success' // one task running succeeded
-const Failure = 'failure' // one task ran failed
-const Timeout = 'timeout' // total timeout
-const TaskTimeout = 'task-timeout' // one task timed out
-const Completed = 'complete' // all retries completed
-const MaxRetries = 'max-retries' // Reach the max retries
-
-module.exports = {
-  Start,
-  Retry,
-  Success,
-  Failure,
-  Timeout,
-  TaskTimeout,
-  Stop,
-  Completed,
-  MaxRetries
-}

package/lib/index.js

@@ -1,28 +0,0 @@
-'use strict'
-// 3rd
-const { LangUtils } = require('@creejs/commons-lang')
-
-// owned
-const Policy = require('./policy')
-const Retrier = require('./retrier')
-const Event = require('./event')
-const RetrierFactory = require('./retrier-factory')
-
-/**
- * Add all factory methods to Retrier as static methods.
- * Now we can create do something like this:
- * ```
- * Retrier.name('myRetrier')
- * Retrier.infinite()
- * ...
- * ```
- */
-LangUtils.defaults(Retrier, RetrierFactory)
-
-module.exports = {
-  Policy,
-  Retrier,
-  Event,
-  RetrierFactory,
-  ...RetrierFactory
-}

package/lib/policy/factor-increase-policy.js

@@ -1,46 +0,0 @@
-'use strict'
-// 3rd
-// internal
-const { TypeAssert: { assertPositive } } = require('@creejs/commons-lang')
-// owned
-const Policy = require('../policy')
-
-class FactoreIncreasePolicy extends Policy {
-  /**
-   * each call to _next() increases the interval by lastInterval * factor
-   * @param {number} factor - the increasement factor, >= 1
-   */
-  constructor (factor) {
-    super()
-    assertPositive(factor, 'factor')
-    if (factor < 1) {
-      throw new Error('factor must be >= 1')
-    }
-    this._factor = factor
-  }
-
-  set factor (factor) {
-    assertPositive(factor, 'factor')
-    if (factor < 1) {
-      throw new Error('factor must be >= 1')
-    }
-    this._factor = factor
-  }
-
-  get factor () {
-    return this._factor
-  }
-
-  /**
-   * Interval ms of next execution
-   * @returns {number}
-   */
-  _next () {
-    if (this._nextInterval >= this._max) {
-      return this._max
-    }
-    return this._nextInterval * this.factor
-  }
-}
-
-module.exports = FactoreIncreasePolicy

package/lib/policy/fixed-increase-policy.js

@@ -1,40 +0,0 @@
-'use strict'
-// 3rd
-// internal
-const { TypeAssert: { assertPositive } } = require('@creejs/commons-lang')
-// owned
-const Policy = require('../policy')
-
-class FixedIncreasePolicy extends Policy {
-  /**
-   * each call to _next() increases the interval by "increasement".
-   * @param {number} increasement - The fixed interval (in milliseconds) between retry attempts.
-   */
-  constructor (increasement) {
-    super()
-    assertPositive(increasement, 'increasement')
-    this._increasement = increasement
-  }
-
-  set increasement (increasement) {
-    assertPositive(increasement, 'increasement')
-    this._increasement = increasement
-  }
-
-  get increasement () {
-    return this._increasement
-  }
-
-  /**
-   * Interval ms of next execution
-   * @returns {number}
-   */
-  _next () {
-    if (this._nextInterval >= this._max) {
-      return this._max
-    }
-    return this._nextInterval + this.increasement
-  }
-}
-
-module.exports = FixedIncreasePolicy

package/lib/policy/fixed-interval-policy.js

@@ -1,38 +0,0 @@
-'use strict'
-// 3rd
-// internal
-const { TypeAssert: { assertPositive } } = require('@creejs/commons-lang')
-// owned
-const Policy = require('../policy')
-
-class FixedIntervalPolicy extends Policy {
-  /**
-   * Creates a fixed interval retry policy with the specified interval.
-   * @param {number} interval - The fixed interval (in milliseconds) between retry attempts.
-   */
-  constructor (interval) {
-    super()
-    assertPositive(interval, 'interval')
-    this._interval = interval
-  }
-
-  set interval (interval) {
-    assertPositive(interval, 'interval')
-    this._interval = interval
-  }
-
-  get interval () {
-    return this._interval
-  }
-
-  /**
-   * Interval ms of next execution
-   * @returns {number}
-   * @throws {Error} Always throws "Not Implemented Yet" error.
-   */
-  _next () {
-    return this.interval
-  }
-}
-
-module.exports = FixedIntervalPolicy

package/lib/policy/shuttle-policy.js

@@ -1,49 +0,0 @@
-'use strict'
-// 3rd
-// internal
-const { TypeAssert: { assertPositive } } = require('@creejs/commons-lang')
-
-// owned
-const Policy = require('../policy')
-
-class ShuttlePolicy extends Policy {
-  /**
-   * the inteval value shuttles between min and max
-   * @param {number} stepLength - the step length to change
-   */
-  constructor (stepLength) {
-    super()
-    assertPositive(stepLength, 'stepLength')
-    this._stepLength = stepLength
-    this.increasement = stepLength
-  }
-
-  set stepLength (stepLength) {
-    assertPositive(stepLength, 'stepLength')
-    this._stepLength = stepLength
-    this.increasement = stepLength
-  }
-
-  get stepLength () {
-    return this._stepLength
-  }
-
-  /**
-   * Interval ms of next execution
-   * @returns {number}
-   * @throws {Error} Always throws "Not Implemented Yet" error.
-   */
-  _next () {
-    const nextInterval = this._nextInterval + this.increasement
-    if (nextInterval >= this._max) {
-      this.increasement = -this.stepLength
-      return this._max
-    } else if (nextInterval <= this._min) {
-      this.increasement = this.stepLength
-      return this._min
-    }
-    return nextInterval
-  }
-}
-
-module.exports = ShuttlePolicy