@creejs/commons-retrier 1.0.6 → 1.0.8

package/README.md

@@ -51,8 +51,7 @@ npm intall @creejs/commons-retrier
 1. retry(task)
 
    ```javascript
-   'use strict'
-   const { Retrier } = require('@creejs/commons-retrier')
+      const { Retrier } = require('@creejs/commons-retrier')
    
    // Chainable API to create and initialize Retrier
    const retrier = Retrier.infinite() // no retry limit
@@ -84,8 +83,7 @@ npm intall @creejs/commons-retrier
 2. always(task)
 
    ```javas
-   'use strict'
-   
+      
    const { Retrier } = require('@creejs/commons-retrier')
    
    // Chainable API to create and initialize Retrier

package/index.js

@@ -1,3 +1,2 @@
-'use strict'
-
-module.exports = require('./lib')
+export { default } from './lib/index.js'
+export * from './lib/index.js'

package/lib/alway-task.js

@@ -1,11 +1,11 @@
-'use strict'
-
 // owned
-// eslint-disable-next-line no-unused-vars
-const Retrier = require('./retrier')
-const Task = require('./task')
+import Task from './task.js'
+
+/**
+ * @typedef {import('./retrier.js').default} Retrier
+ */
 
-class AlwaysTask extends Task {
+export default class AlwaysTask extends Task {
   /**
    * Checks if the given task is an instance of AlwaysTask.
    * @param {*} task - The task to check.
@@ -41,4 +41,4 @@ class AlwaysTask extends Task {
   }
 }
 
-module.exports = AlwaysTask
+export { AlwaysTask as AlwaysTaskType }

package/lib/constants.js

@@ -1,10 +1,8 @@
-'use strict'
 // module vars
-const DefaultMinInterval = 50
-const DefaultMaxInterval = 30 * 1000 // 30s
-
-const DefaultMaxRetries = 3
-module.exports = {
+export const DefaultMinInterval = 50
+export const DefaultMaxInterval = 30 * 1000 // 30s
+export const DefaultMaxRetries = 3
+export default {
   DefaultMinInterval,
   DefaultMaxInterval,
   DefaultMaxRetries

package/lib/event.js

@@ -1,15 +1,14 @@
-'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
+export const Start = 'start' // retry started
+export const Stop = 'stop' // retry stopped
+export const Retry = 'retry' // one retry began
+export const Success = 'success' // one task running succeeded
+export const Failure = 'failure' // one task ran failed
+export const Timeout = 'timeout' // total timeout
+export const TaskTimeout = 'task-timeout' // one task timed out
+export const Completed = 'complete' // all retries completed
+export const MaxRetries = 'max-retries' // Reach the max retries
 
-module.exports = {
+export default {
   Start,
   Retry,
   Success,

package/lib/index.js

@@ -1,12 +1,11 @@
-'use strict'
 // 3rd
-const { LangUtils } = require('@creejs/commons-lang')
+import { LangUtils } from '@creejs/commons-lang'
 
 // owned
-const Policy = require('./policy')
-const Retrier = require('./retrier')
-const Event = require('./event')
-const RetrierFactory = require('./retrier-factory')
+import Policy from './policy.js'
+import Retrier from './retrier.js'
+import Event from './event.js'
+import RetrierFactory from './retrier-factory.js'
 
 /**
  * Add all factory methods to Retrier as static methods.
@@ -19,10 +18,27 @@ const RetrierFactory = require('./retrier-factory')
  */
 LangUtils.defaults(Retrier, RetrierFactory)
 
-module.exports = {
+/**
+ * default export to support
+ * 1. import CommonsRetrier from '@creejs/commons-retrier'
+ */
+export default {
   Policy,
   Retrier,
   Event,
   RetrierFactory,
   ...RetrierFactory
 }
+
+/**
+ * named export to support
+ * 1. import { Retrier } from '@creejs/commons-retrier'
+ * 2. import * as CommonsRetrier from '@creejs/commons-retrier'
+ */
+export {
+  Policy,
+  Retrier,
+  Event,
+  RetrierFactory
+}
+export * from './retrier-factory.js'

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

@@ -1,11 +1,12 @@
-'use strict'
 // 3rd
 // internal
-const { TypeAssert: { assertPositive } } = require('@creejs/commons-lang')
+import { TypeAssert } from '@creejs/commons-lang'
 // owned
-const Policy = require('../policy')
+import Policy from '../policy.js'
+// module vars
+const { assertPositive } = TypeAssert
 
-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
@@ -42,5 +43,4 @@ class FactoreIncreasePolicy extends Policy {
     return this._nextInterval * this.factor
   }
 }
-
-module.exports = FactoreIncreasePolicy
+export { FactoreIncreasePolicy as FactoreIncreasePolicyType }

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

@@ -1,11 +1,11 @@
-'use strict'
 // 3rd
 // internal
-const { TypeAssert: { assertPositive } } = require('@creejs/commons-lang')
+import { TypeAssert } from '@creejs/commons-lang'
 // owned
-const Policy = require('../policy')
-
-class FixedIncreasePolicy extends Policy {
+import Policy from '../policy.js'
+// module vars
+const { assertPositive } = TypeAssert
+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.
@@ -36,5 +36,4 @@ class FixedIncreasePolicy extends Policy {
     return this._nextInterval + this.increasement
   }
 }
-
-module.exports = FixedIncreasePolicy
+export { FixedIncreasePolicy as FixedIncreasePolicyType }

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

@@ -1,11 +1,11 @@
-'use strict'
 // 3rd
 // internal
-const { TypeAssert: { assertPositive } } = require('@creejs/commons-lang')
+import { TypeAssert } from '@creejs/commons-lang'
 // owned
-const Policy = require('../policy')
-
-class FixedIntervalPolicy extends Policy {
+import Policy from '../policy.js'
+// module vars
+const { assertPositive } = TypeAssert
+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.
@@ -35,4 +35,4 @@ class FixedIntervalPolicy extends Policy {
   }
 }
 
-module.exports = FixedIntervalPolicy
+export { FixedIntervalPolicy as FixedIntervalPolicyType }

package/lib/policy/shuttle-policy.js

@@ -1,12 +1,13 @@
-'use strict'
 // 3rd
 // internal
-const { TypeAssert: { assertPositive } } = require('@creejs/commons-lang')
+import { TypeAssert } from '@creejs/commons-lang'
 
 // owned
-const Policy = require('../policy')
+import Policy from '../policy.js'
+// module vars
+const { assertPositive } = TypeAssert
 
-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
@@ -46,4 +47,4 @@ class ShuttlePolicy extends Policy {
   }
 }
 
-module.exports = ShuttlePolicy
+export { ShuttlePolicy as ShuttlePolicyType }

package/lib/policy.js

@@ -1,14 +1,13 @@
-'use strict'
 // internal
-const {
-  TypeAssert: { assertPositive },
-  TypeUtils: { isNumber }
-} = require('@creejs/commons-lang')
+import { TypeAssert, TypeUtils } from '@creejs/commons-lang'
 // owned
-const { DefaultMaxInterval, DefaultMinInterval } = require('./constants')
+import { DefaultMaxInterval, DefaultMinInterval } from './constants.js'
+
 // module vars
+const { assertPositive } = TypeAssert
+const { isNumber } = TypeUtils
 
-class Policy {
+export default class Policy {
   /**
    * Creates a new Policy instance with specified retry bounds.
    */
@@ -128,4 +127,4 @@ class Policy {
     throw new Error('Not Impled Yet')
   }
 }
-module.exports = Policy
+export { Policy as PolicyType }

package/lib/retrier-factory.js

@@ -1,6 +1,5 @@
-'use strict'
 // owned
-const Retrier = require('./retrier')
+import Retrier from './retrier.js'
 /**
  * Creates a new Retrier instance with the specified name.
  * @param {string} name - The name to assign to the retrier.
@@ -155,7 +154,26 @@ function start (task) {
   return retrier.start()
 }
 
-module.exports = {
+// default export
+export default {
+  name,
+  infinite,
+  times,
+  maxRetries,
+  min,
+  max,
+  range,
+  fixedInterval,
+  fixedIncrease,
+  factorIncrease,
+  shuttleInterval,
+  timeout,
+  taskTimeout,
+  start
+}
+
+// named export
+export {
   name,
   infinite,
   times,

package/lib/retrier.js

@@ -1,32 +1,28 @@
-'use strict'
-
 // internal
-const {
-  TypeAssert: { assertPositive, assertString, assertFunction, assertNumber },
-  TypeUtils: { isNil },
-  PromiseUtils
-} = require('@creejs/commons-lang')
-const { EventEmitter } = require('@creejs/commons-events')
+import { TypeAssert, TypeUtils, PromiseUtils } from '@creejs/commons-lang'
+import { EventEmitter } from '@creejs/commons-events'
 
 // owned
 // eslint-disable-next-line no-unused-vars
-const Policy = require('./policy')
-const Event = require('./event')
-const FixedIntervalPolicy = require('./policy/fixed-interval-policy')
-const FixedIncreasePolicy = require('./policy/fixed-increase-policy')
-const FactoreIncreasePolicy = require('./policy/factor-increase-policy')
-const ShuttlePolicy = require('./policy/shuttle-policy')
-const Task = require('./task')
-const AlwaysTask = require('./alway-task')
-const { DefaultMaxRetries } = require('./constants')
+import Policy from './policy.js'
+import Event from './event.js'
+import FixedIntervalPolicy from './policy/fixed-interval-policy.js'
+import FixedIncreasePolicy from './policy/fixed-increase-policy.js'
+import FactoreIncreasePolicy from './policy/factor-increase-policy.js'
+import ShuttlePolicy from './policy/shuttle-policy.js'
+import Task from './task.js'
+import AlwaysTask from './alway-task.js'
+import { DefaultMaxRetries } from './constants.js'
 
 // module vars
+const { assertPositive, assertString, assertFunction, assertNumber } = TypeAssert
+const { isNil } = TypeUtils
 const TaskTimoutFlag = '!#@%$&^*'
 
 /**
  * @extends EventEmitter
  */
-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.
@@ -531,4 +527,4 @@ function isInfinite (value) {
   return value <= 0 || value === Infinity
 }
 
-module.exports = Retrier
+export { Retrier as RetrierType }

package/lib/task.js

@@ -1,11 +1,13 @@
-'use strict'
-
-const { TypeAssert: { assertNotNil, assertFunction } } = require('@creejs/commons-lang')
+import { TypeAssert } from '@creejs/commons-lang'
 // owned
-// eslint-disable-next-line no-unused-vars
-const Retrier = require('./retrier')
 
-class Task {
+/**
+ * @typedef {import('./retrier.js').default} Retrier
+ */
+
+// module vars
+const { assertNotNil, assertFunction } = TypeAssert
+export default class Task {
   /**
    * Creates a new Task instance.
    * @param {Retrier} retrier - The retrier instance.
@@ -53,4 +55,4 @@ class Task {
   }
 }
 
-module.exports = Task
+export { Task as TaskType }

package/package.json

@@ -1,9 +1,19 @@
 {
   "name": "@creejs/commons-retrier",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Common Utils About Task Retrying",
-  "main": "index.js",
+  "keywords": [
+    "commons",
+    "creejs",
+    "retrier",
+    "retry",
+    "always",
+    "task",
+    "variable delay",
+    "variable interval"
+  ],
   "private": false,
+  "type": "module",
   "files": [
     "index.js",
     "lib/",
@@ -11,6 +21,26 @@
     "README.md"
   ],
   "types": "types/index.d.ts",
+  "main": "./dist/esm/index-min.js",
+  "exports": {
+    ".": {
+      "import": {
+        "development": "./dist/esm/index-dev.js",
+        "production": "./dist/esm/index-min.js",
+        "default": "./dist/esm/index-min.js"
+      },
+      "require": {
+        "development": "./dist/cjs/index-dev.cjs",
+        "production": "./dist/cjs/index-min.cjs",
+        "default": "./dist/cjs/index-min.cjs"
+      },
+      "browser": {
+        "development": "./dist/umd/index-dev.js",
+        "production": "./dist/umd/index-min.js",
+        "default": "./dist/cjs/index-min.js"
+      }
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -20,13 +50,17 @@
   },
   "scripts": {
     "dts": "tsc",
-    "generate-docs": "../../node_modules/.bin/jsdoc -c ./jsdoc.json"
+    "generate-docs": "../../node_modules/.bin/jsdoc -c ./jsdoc.json",
+    "clean": "rm -rf dist && rm -rf types && rm -rf docs",
+    "build": "npm run clean && npm run dts && rollup -c",
+    "prepublishOnly": "npm run build",
+    "publish": "npm run prepublishOnly && npm publish"
   },
   "author": "rodney.vin@gmail.com",
   "license": "Apache-2.0",
   "dependencies": {
-    "@creejs/commons-events": "^1.0.3",
-    "@creejs/commons-lang": "^1.0.3"
+    "@creejs/commons-events": "^1.0.9",
+    "@creejs/commons-lang": "^1.0.10"
   },
   "devDependencies": {}
 }

package/types/alway-task.d.ts

@@ -1,5 +1,7 @@
-export = AlwaysTask;
-declare class AlwaysTask extends Task {
+/**
+ * @typedef {import('./retrier.js').default} Retrier
+ */
+export default class AlwaysTask extends Task {
     /**
      * Checks if the given task is an instance of AlwaysTask.
      * @param {*} task - The task to check.
@@ -23,5 +25,6 @@ declare class AlwaysTask extends Task {
      */
     execute(retries: number, latence: number, nextInterval: number): Promise<any>;
 }
-import Task = require("./task");
-import Retrier = require("./retrier");
+export { AlwaysTask as AlwaysTaskType };
+export type Retrier = import('./retrier.js').default;
+import Task from "./task.js";

package/types/constants.d.ts

@@ -1,3 +1,9 @@
 export const DefaultMinInterval: 50;
 export const DefaultMaxInterval: number;
 export const DefaultMaxRetries: 3;
+declare namespace _default {
+    export { DefaultMinInterval };
+    export { DefaultMaxInterval };
+    export { DefaultMaxRetries };
+}
+export default _default;

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;