rclnodejs 0.30.0 → 0.31.0

package/README.md

@@ -45,7 +45,7 @@ npm i rclnodejs@x.y.z
 
 |                                      RCLNODEJS Version                                       |                                                             Compatible ROS 2 LTS                                                             |
 | :------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------: |
-| latest version (currently [v0.30.0](https://github.com/RobotWebTools/rclnodejs/tree/0.30.0)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
+| latest version (currently [v0.31.0](https://github.com/RobotWebTools/rclnodejs/tree/0.31.0)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
 
 ## Documentation
 

package/lib/action/server.js

@@ -266,10 +266,12 @@ class ActionServer extends Entity {
     let goalHandle;
     if (accepted) {
       // Stamp time of acceptance
-      const secondsAndNanos = this._node.getClock().now().secondsAndNanoseconds;
+      const { seconds, nanoseconds } = this._node
+        .getClock()
+        .now().secondsAndNanoseconds;
       goalInfo.stamp = {
-        sec: secondsAndNanos.seconds,
-        nanosec: secondsAndNanos.nanoseconds,
+        sec: Number(seconds),
+        nanosec: Number(nanoseconds),
       };
 
       try {

package/lib/clock.js

@@ -52,8 +52,8 @@ class Clock {
    * @return {Time} Return the current time.
    */
   now() {
-    let time = rclnodejs.clockGetNow(this._handle);
-    return new Time(time.sec, time.nanosec, this._clockType);
+    const nowInNanosec = rclnodejs.clockGetNow(this._handle);
+    return new Time(0n, nowInNanosec, this._clockType);
   }
 }
 

package/lib/duration.js

@@ -15,7 +15,7 @@
 'use strict';
 
 const rclnodejs = require('bindings')('rclnodejs');
-const int64 = require('int64-napi');
+const S_TO_NS = 10n ** 9n;
 
 /**
  * @class - Class representing a Duration in ROS
@@ -24,51 +24,38 @@ const int64 = require('int64-napi');
 class Duration {
   /**
    * Create a Duration.
-   * @param {number|string} [seconds=0] - The second part of the duration.
-   * @param {number|string} [nanoseconds=0] - The nanosecond part of the duration.
+   * @param {bigint} [seconds=0] - The second part of the duration.
+   * @param {bigint} [nanoseconds=0] - The nanosecond part of the duration.
    */
-  constructor(seconds = 0, nanoseconds = 0) {
-    if (typeof seconds !== 'number' && typeof seconds !== 'string') {
+  constructor(seconds = 0n, nanoseconds = 0n) {
+    if (typeof seconds !== 'bigint') {
       throw new TypeError('Invalid argument of seconds');
     }
 
-    if (typeof nanoseconds !== 'number' && typeof nanoseconds !== 'string') {
+    if (typeof nanoseconds !== 'bigint') {
       throw new TypeError('Invalid argument of nanoseconds');
     }
 
-    let secondInt64 = int64.from(seconds);
-    let nanoInt64 = int64.from(nanoseconds);
-
-    if (typeof seconds === 'string' && seconds.startsWith('-')) {
-      secondInt64 = int64.negative(secondInt64);
-    }
-    if (typeof nanoseconds === 'string' && nanoseconds.startsWith('-')) {
-      nanoInt64 = int64.negative(nanoInt64);
+    const total = seconds * S_TO_NS + nanoseconds;
+    if (total >= 2n ** 63n) {
+      throw new RangeError(
+        'Total nanoseconds value is too large to store in C time point.'
+      );
     }
-    this._nanoseconds = secondInt64.multiply(1e9).add(nanoInt64);
-    this._handle = rclnodejs.createDuration(this._nanoseconds.toString());
+
+    this._nanoseconds = total;
+    this._handle = rclnodejs.createDuration(this._nanoseconds);
   }
 
   /**
    * Get the nanosecond part of the Duration.
    * @name Duration#get:nanoseconds
    * @function
-   * @return {number|string} - value in nanosecond, if the value is greater than Number.MAX_SAFE_INTEGER (2^53-1), will be presented in string of decimal format.
+   * @return {bigint} - value in nanosecond.
    */
 
   get nanoseconds() {
-    let nanoStr = rclnodejs.getDurationNanoseconds(this._handle);
-    let nano;
-
-    if (nanoStr.startsWith('-')) {
-      nano = int64.negative(int64.from(nanoStr));
-    } else {
-      nano = int64.from(nanoStr);
-    }
-    if (Number.isFinite(nano.toNumber())) {
-      return nano.toNumber();
-    }
-    return nano.toString();
+    return rclnodejs.getDurationNanoseconds(this._handle);
   }
 
   /**
@@ -78,7 +65,7 @@ class Duration {
    */
   eq(other) {
     if (other instanceof Duration) {
-      return this._nanoseconds.eq(other.nanoseconds);
+      return this._nanoseconds === other.nanoseconds;
     }
     throw new TypeError(
       `Can't compare duration with object of type: ${other.constructor.name}`
@@ -92,7 +79,7 @@ class Duration {
    */
   ne(other) {
     if (other instanceof Duration) {
-      return this._nanoseconds.ne(other.nanoseconds);
+      return this._nanoseconds !== other.nanoseconds;
     }
     throw new TypeError('Invalid argument');
   }
@@ -104,7 +91,7 @@ class Duration {
    */
   lt(other) {
     if (other instanceof Duration) {
-      return this._nanoseconds.lt(other.nanoseconds);
+      return this._nanoseconds < other.nanoseconds;
     }
     throw new TypeError('Invalid argument');
   }
@@ -116,7 +103,7 @@ class Duration {
    */
   lte(other) {
     if (other instanceof Duration) {
-      return this._nanoseconds.lte(other.nanoseconds);
+      return this._nanoseconds <= other.nanoseconds;
     }
     throw new TypeError('Invalid argument');
   }
@@ -128,7 +115,7 @@ class Duration {
    */
   gt(other) {
     if (other instanceof Duration) {
-      return this._nanoseconds.gt(other.nanoseconds);
+      return this._nanoseconds > other.nanoseconds;
     }
     throw new TypeError('Invalid argument');
   }
@@ -140,7 +127,7 @@ class Duration {
    */
   gte(other) {
     if (other instanceof Duration) {
-      return this._nanoseconds.gte(other.nanoseconds);
+      return this._nanoseconds >= other.nanoseconds;
     }
     throw new TypeError('Invalid argument');
   }

package/lib/node.js

@@ -507,7 +507,7 @@ class Node extends rclnodejs.ShadowNode {
 
   /**
    * Create a Timer.
-   * @param {number} period - The number representing period in millisecond.
+   * @param {bigint} period - The number representing period in nanoseconds.
    * @param {function} callback - The callback to be called when timeout.
    * @param {Clock} [clock] - The clock which the timer gets time from.
    * @return {Timer} - An instance of Timer.
@@ -519,22 +519,11 @@ class Node extends rclnodejs.ShadowNode {
       clock = arguments[3];
     }
 
-    if (typeof period !== 'number' || typeof callback !== 'function') {
+    if (typeof period !== 'bigint' || typeof callback !== 'function') {
       throw new TypeError('Invalid argument');
     }
 
-    // The period unit is millisecond in JavaScript side. When being passed to the
-    // C++ side, the value will be converted to nanosecond, which goes into a uint64_t
-    // with maxmium value of 2^64-1. So the maxmium is UINT64_MAX in ns, that's 0x10c6f7a0b5ed in ms.
-    const MAX_TIMER_PERIOD_IN_MILLISECOND = 0x10c6f7a0b5ed;
-    if (period > 0x10c6f7a0b5ed || period < 0) {
-      throw new RangeError(
-        `Parameter must be between 0.0 and ${MAX_TIMER_PERIOD_IN_MILLISECOND}`
-      );
-    }
-
     const timerClock = clock || this._clock;
-
     let timerHandle = rclnodejs.createTimer(
       timerClock.handle,
       this.context.handle,
@@ -573,7 +562,7 @@ class Node extends rclnodejs.ShadowNode {
     }
 
     const period = Math.round(1000 / hz);
-    const timer = this._rateTimerServer.createTimer(period);
+    const timer = this._rateTimerServer.createTimer(BigInt(period) * 1000000n);
     const rate = new Rates.Rate(hz, timer);
 
     return rate;
@@ -1480,10 +1469,10 @@ class Node extends rclnodejs.ShadowNode {
       PARAMETER_EVENT_MSG_TYPE
     ))();
 
-    const secondsAndNanos = this._clock.now().secondsAndNanoseconds;
+    const { seconds, nanoseconds } = this._clock.now().secondsAndNanoseconds;
     parameterEvent.stamp = {
-      sec: secondsAndNanos.seconds,
-      nanosec: secondsAndNanos.nanoseconds,
+      sec: Number(seconds),
+      nanosec: Number(nanoseconds),
     };
 
     parameterEvent.node =

package/lib/rate.js

@@ -166,7 +166,7 @@ class RateTimerServer {
   /**
    * Create a new timer instance with callback set to NOP.
    *
-   * @param {number} period - The period in milliseconds
+   * @param {bigint} period - The period in nanoseconds.
    * @returns {Timer} - The new timer instance.
    */
   createTimer(period) {

package/lib/time.js

@@ -17,7 +17,7 @@
 const rclnodejs = require('bindings')('rclnodejs');
 const Duration = require('./duration.js');
 const ClockType = require('./clock_type.js');
-const int64 = require('int64-napi');
+const S_TO_NS = 10n ** 9n;
 
 /**
  * @class - Class representing a Time in ROS
@@ -26,16 +26,20 @@ const int64 = require('int64-napi');
 class Time {
   /**
    * Create a Time.
-   * @param {number|string} [seconds=0] - The second part of the time.
-   * @param {number|string} [nanoseconds=0] - The nanosecond part of the time.
+   * @param {bigint} [seconds=0] - The second part of the time.
+   * @param {bigint} [nanoseconds=0] - The nanosecond part of the time.
    * @param {ClockType} [clockType=Clock.ClockType.SYSTEM_TIME] - The clock type.
    */
-  constructor(seconds = 0, nanoseconds = 0, clockType = ClockType.SYSTEM_TIME) {
-    if (typeof seconds !== 'number' && typeof seconds !== 'string') {
+  constructor(
+    seconds = 0n,
+    nanoseconds = 0n,
+    clockType = ClockType.SYSTEM_TIME
+  ) {
+    if (typeof seconds !== 'bigint') {
       throw new TypeError('Invalid argument of seconds');
     }
 
-    if (typeof nanoseconds !== 'number' && typeof nanoseconds !== 'string') {
+    if (typeof nanoseconds !== 'bigint') {
       throw new TypeError('Invalid argument of nanoseconds');
     }
 
@@ -43,25 +47,22 @@ class Time {
       throw new TypeError('Invalid argument of clockType');
     }
 
-    if (
-      int64.lt(seconds, 0) ||
-      (typeof seconds === 'string' && seconds.startsWith('-'))
-    ) {
+    if (seconds < 0n) {
       throw new RangeError('seconds value must not be negative');
     }
 
-    if (
-      int64.lt(nanoseconds, 0) ||
-      (typeof nanoseconds === 'string' && nanoseconds.startsWith('-'))
-    ) {
+    if (nanoseconds < 0n) {
       throw new RangeError('nanoseconds value must not be negative');
     }
 
-    this._nanoseconds = int64.from(seconds).multiply(1e9).add(nanoseconds);
-    this._handle = rclnodejs.createTimePoint(
-      this._nanoseconds.toString(),
-      clockType
-    );
+    const total = seconds * S_TO_NS + nanoseconds;
+    if (total >= 2n ** 63n) {
+      throw new RangeError(
+        'Total nanoseconds value is too large to store in C time point.'
+      );
+    }
+    this._nanoseconds = total;
+    this._handle = rclnodejs.createTimePoint(this._nanoseconds, clockType);
     this._clockType = clockType;
   }
 
@@ -80,22 +81,11 @@ class Time {
    * Get the nanosecond part of the time.
    * @name Time#get:nanoseconds
    * @function
-   * @return {number|string} - value in nanosecond, if the value is greater than Number.MAX_SAFE_INTEGER (2^53-1), will be presented in string of decimal format.
+   * @return {bigint} - value in nanosecond.
    */
 
   get nanoseconds() {
-    let str = rclnodejs.getNanoseconds(this._handle);
-    let nano;
-
-    if (str.startsWith('-')) {
-      nano = int64.negative(int64.from(str));
-    } else {
-      nano = int64.from(str);
-    }
-    if (Number.isFinite(nano.toNumber())) {
-      return nano.toNumber();
-    }
-    return nano.toString();
+    return rclnodejs.getNanoseconds(this._handle);
   }
 
   /**
@@ -106,9 +96,11 @@ class Time {
    */
 
   get secondsAndNanoseconds() {
-    const seconds = int64.from(this._nanoseconds).divide(1e9).toNumber();
-    const nanoseconds = int64.from(this._nanoseconds).mod(1e9).toNumber();
-    return { seconds, nanoseconds };
+    const nanoseconds = this._nanoseconds;
+    return {
+      seconds: nanoseconds / S_TO_NS,
+      nanoseconds: nanoseconds % S_TO_NS,
+    };
   }
 
   /**
@@ -119,8 +111,8 @@ class Time {
   add(other) {
     if (other instanceof Duration) {
       return new Time(
-        0,
-        int64.add(this._nanoseconds, other.nanoseconds).toString(),
+        0n,
+        this._nanoseconds + other.nanoseconds,
         this._clockType
       );
     }
@@ -137,14 +129,11 @@ class Time {
       if (other._clockType !== this._clockType) {
         throw new TypeError("Can't subtract times with different clock types");
       }
-      return new Duration(
-        0,
-        int64.subtract(this._nanoseconds, other._nanoseconds).toString()
-      );
+      return new Duration(0n, this._nanoseconds - other._nanoseconds);
     } else if (other instanceof Duration) {
       return new Time(
-        0,
-        int64.subtract(this._nanoseconds, other._nanoseconds).toString(),
+        0n,
+        this._nanoseconds - other._nanoseconds,
         this._clockType
       );
     }
@@ -161,7 +150,7 @@ class Time {
       if (other._clockType !== this._clockType) {
         throw new TypeError("Can't compare times with different clock types");
       }
-      return this._nanoseconds.eq(other.nanoseconds);
+      return this._nanoseconds === other.nanoseconds;
     }
     throw new TypeError('Invalid argument');
   }
@@ -176,7 +165,7 @@ class Time {
       if (other._clockType !== this._clockType) {
         throw new TypeError("Can't compare times with different clock types");
       }
-      return this._nanoseconds.ne(other.nanoseconds);
+      return this._nanoseconds !== other.nanoseconds;
     }
   }
 
@@ -190,7 +179,7 @@ class Time {
       if (other._clockType !== this._clockType) {
         throw new TypeError("Can't compare times with different clock types");
       }
-      return this._nanoseconds.lt(other.nanoseconds);
+      return this._nanoseconds < other.nanoseconds;
     }
     throw new TypeError('Invalid argument');
   }
@@ -205,7 +194,7 @@ class Time {
       if (other._clockType !== this._clockType) {
         throw new TypeError("Can't compare times with different clock types");
       }
-      return this._nanoseconds.lte(other.nanoseconds);
+      return this._nanoseconds <= other.nanoseconds;
     }
     throw new TypeError('Invalid argument');
   }
@@ -220,7 +209,7 @@ class Time {
       if (other._clockType !== this._clockType) {
         throw new TypeError("Can't compare times with different clock types");
       }
-      return this._nanoseconds.gt(other.nanoseconds);
+      return this._nanoseconds > other.nanoseconds;
     }
     throw new TypeError('Invalid argument');
   }
@@ -235,7 +224,7 @@ class Time {
       if (other._clockType !== this._clockType) {
         throw new TypeError("Can't compare times with different clock types");
       }
-      return this._nanoseconds.gte(other.nanoseconds);
+      return this._nanoseconds >= other.nanoseconds;
     }
     throw new TypeError('Invalid argument');
   }
@@ -261,7 +250,7 @@ class Time {
    * @return {Time} Return the created Time object.
    */
   static fromMsg(msg, clockType = ClockType.ROS_TIME) {
-    return new Time(msg.sec, msg.nanosec, clockType);
+    return new Time(BigInt(msg.sec), BigInt(msg.nanosec), clockType);
   }
 }
 

package/lib/time_source.js

@@ -37,7 +37,7 @@ class TimeSource {
     this._node = node;
     this._associatedClocks = [];
     this._clockSubscription = undefined;
-    this._lastTimeSet = new Time(0, 0, ClockType.ROS_TIME);
+    this._lastTimeSet = new Time(0n, 0n, ClockType.ROS_TIME);
     this._isRosTimeActive = false;
 
     if (this._node) {

package/lib/timer.js

@@ -29,7 +29,7 @@ class Timer {
   }
 
   /**
-   * @type {number}
+   * @type {bigint} - The period of the timer in nanoseconds.
    */
   get period() {
     return this._period;
@@ -73,18 +73,18 @@ class Timer {
 
   /**
    * Get the interval since the last call of this timer.
-   * @return {number} - the interval value - ms.
+   * @return {bigint} - the interval value in nanoseconds.
    */
   timeSinceLastCall() {
-    return parseInt(rclnodejs.timerGetTimeSinceLastCall(this._handle), 10);
+    return rclnodejs.timerGetTimeSinceLastCall(this._handle);
   }
 
   /**
    * Get the interval until the next call will happen.
-   * @return {number} - the interval value - ms.
+   * @return {bigint} - the interval value in nanoseconds.
    */
   timeUntilNextCall() {
-    return parseInt(rclnodejs.timerGetTimeUntilNextCall(this._handle), 10);
+    return rclnodejs.timerGetTimeUntilNextCall(this._handle);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rclnodejs",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "description": "ROS2.0 JavaScript client with Node.js",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -63,7 +63,6 @@
     "tree-kill": "^1.2.2",
     "typescript": "^5.7.2"
   },
-  "//": "Pin int64-napi to ^1.0.2",
   "dependencies": {
     "@rclnodejs/ref-array-di": "^1.2.2",
     "@rclnodejs/ref-napi": "^4.0.0",
@@ -76,7 +75,6 @@
     "dtslint": "^4.2.1",
     "fs-extra": "^11.2.0",
     "json-bigint": "^1.0.0",
-    "int64-napi": "^1.0.2",
     "is-close": "^1.3.3",
     "mkdirp": "^3.0.1",
     "mz": "^2.7.0",

package/scripts/npmjs-readme.md

@@ -45,7 +45,7 @@ npm i rclnodejs@x.y.z
 
 |                                      RCLNODEJS Version                                       |                                                             Compatible ROS 2 LTS                                                             |
 | :------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------------------------------: |
-| latest version (currently [v0.30.0](https://github.com/RobotWebTools/rclnodejs/tree/0.30.0)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
+| latest version (currently [v0.31.0](https://github.com/RobotWebTools/rclnodejs/tree/0.31.0)) | [Humble](https://github.com/RobotWebTools/rclnodejs/tree/humble-hawksbill)<br>[Jazzy](https://github.com/RobotWebTools/rclnodejs/tree/jazzy) |
 
 ## Documentation
 

package/src/rcl_bindings.cpp

@@ -319,8 +319,12 @@ NAN_METHOD(CreateTimer) {
       Nan::To<v8::Object>(info[1]).ToLocalChecked());
   rcl_context_t* context =
       reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-  int64_t period_ms = Nan::To<int64_t>(info[2]).FromJust();
-
+  if (!info[2]->IsBigInt()) {
+    Nan::ThrowTypeError("Timer period must be a BigInt");
+    return;
+  }
+  v8::Local<v8::BigInt> bigInt = info[2].As<v8::BigInt>();
+  int64_t period_nsec = bigInt->Int64Value();
   rcl_timer_t* timer =
       reinterpret_cast<rcl_timer_t*>(malloc(sizeof(rcl_timer_t)));
   *timer = rcl_get_zero_initialized_timer();
@@ -328,15 +332,14 @@ NAN_METHOD(CreateTimer) {
 #if ROS_VERSION > 2305  // After Iron.
   THROW_ERROR_IF_NOT_EQUAL(
       RCL_RET_OK,
-      rcl_timer_init2(timer, clock, context, RCL_MS_TO_NS(period_ms), nullptr,
+      rcl_timer_init2(timer, clock, context, period_nsec, nullptr,
                       rcl_get_default_allocator(), /*autostart=*/true),
       rcl_get_error_string().str);
 #else
-  THROW_ERROR_IF_NOT_EQUAL(
-      RCL_RET_OK,
-      rcl_timer_init(timer, clock, context, RCL_MS_TO_NS(period_ms), nullptr,
-                     rcl_get_default_allocator()),
-      rcl_get_error_string().str);
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_timer_init(timer, clock, context, period_nsec,
+                                          nullptr, rcl_get_default_allocator()),
+                           rcl_get_error_string().str);
 #endif
 
   auto js_obj = RclHandle::NewInstance(timer, clock_handle, [](void* ptr) {
@@ -410,9 +413,9 @@ NAN_METHOD(TimerGetTimeUntilNextCall) {
       RCL_RET_OK, rcl_timer_get_time_until_next_call(timer, &remaining_time),
       rcl_get_error_string().str);
 
-  info.GetReturnValue().Set(
-      Nan::New<v8::String>(std::to_string(RCL_NS_TO_MS(remaining_time)))
-          .ToLocalChecked());
+  v8::Local<v8::BigInt> bigInt =
+      v8::BigInt::New(v8::Isolate::GetCurrent(), remaining_time);
+  info.GetReturnValue().Set(bigInt);
 }
 
 NAN_METHOD(TimerGetTimeSinceLastCall) {
@@ -425,18 +428,23 @@ NAN_METHOD(TimerGetTimeSinceLastCall) {
       RCL_RET_OK, rcl_timer_get_time_since_last_call(timer, &elapsed_time),
       rcl_get_error_string().str);
 
-  info.GetReturnValue().Set(
-      Nan::New<v8::String>(std::to_string(RCL_NS_TO_MS(elapsed_time)))
-          .ToLocalChecked());
+  v8::Local<v8::BigInt> bigInt =
+      v8::BigInt::New(v8::Isolate::GetCurrent(), elapsed_time);
+  info.GetReturnValue().Set(bigInt);
 }
 
 NAN_METHOD(CreateTimePoint) {
-  std::string str(*Nan::Utf8String(info[0]));
+  if (!info[0]->IsBigInt()) {
+    Nan::ThrowTypeError("Timer period must be a BigInt");
+    return;
+  }
+  v8::Local<v8::BigInt> bigInt = info[0].As<v8::BigInt>();
+  const int64_t nanoseconds = bigInt->Int64Value();
   uint32_t clock_type = Nan::To<uint32_t>(info[1]).FromJust();
   rcl_time_point_t* time_point =
       reinterpret_cast<rcl_time_point_t*>(malloc(sizeof(rcl_time_point_t)));
 
-  time_point->nanoseconds = std::stoll(str);
+  time_point->nanoseconds = nanoseconds;
   time_point->clock_type = static_cast<rcl_clock_type_t>(clock_type);
 
   auto js_obj =
@@ -449,16 +457,21 @@ NAN_METHOD(GetNanoseconds) {
       Nan::To<v8::Object>(info[0]).ToLocalChecked());
   rcl_time_point_t* time_point =
       reinterpret_cast<rcl_time_point_t*>(time_point_handle->ptr());
-  info.GetReturnValue().Set(
-      Nan::New<v8::String>(std::to_string(time_point->nanoseconds))
-          .ToLocalChecked());
+  v8::Local<v8::BigInt> bigInt =
+      v8::BigInt::New(v8::Isolate::GetCurrent(), time_point->nanoseconds);
+  info.GetReturnValue().Set(bigInt);
 }
 
 NAN_METHOD(CreateDuration) {
-  std::string str(*Nan::Utf8String(info[0]));
+  if (!info[0]->IsBigInt()) {
+    Nan::ThrowTypeError("Timer period must be a BigInt");
+    return;
+  }
+  v8::Local<v8::BigInt> bigInt = info[0].As<v8::BigInt>();
+  const int64_t nanoseconds = bigInt->Int64Value();
   rcl_duration_t* duration =
       reinterpret_cast<rcl_duration_t*>(malloc(sizeof(rcl_duration_t)));
-  duration->nanoseconds = std::stoll(str);
+  duration->nanoseconds = nanoseconds;
 
   auto js_obj =
       RclHandle::NewInstance(duration, nullptr, [](void* ptr) { free(ptr); });
@@ -470,10 +483,9 @@ NAN_METHOD(GetDurationNanoseconds) {
       Nan::To<v8::Object>(info[0]).ToLocalChecked());
   rcl_duration_t* duration =
       reinterpret_cast<rcl_duration_t*>(duration_handle->ptr());
-
-  info.GetReturnValue().Set(
-      Nan::New<v8::String>(std::to_string(duration->nanoseconds))
-          .ToLocalChecked());
+  v8::Local<v8::BigInt> bigInt =
+      v8::BigInt::New(v8::Isolate::GetCurrent(), duration->nanoseconds);
+  info.GetReturnValue().Set(bigInt);
 }
 
 NAN_METHOD(SetRosTimeOverrideIsEnabled) {
@@ -539,25 +551,6 @@ NAN_METHOD(CreateClock) {
       }));
 }
 
-static void ReturnJSTimeObj(
-    Nan::NAN_METHOD_ARGS_TYPE info, int64_t nanoseconds,
-    rcl_clock_type_t clock_type = RCL_CLOCK_UNINITIALIZED) {
-  auto obj = v8::Object::New(v8::Isolate::GetCurrent());
-
-  const auto sec = static_cast<std::int32_t>(RCL_NS_TO_S(nanoseconds));
-  const auto nanosec =
-      static_cast<std::int32_t>(nanoseconds % (1000 * 1000 * 1000));
-  const int32_t type = clock_type;
-
-  Nan::Set(obj, Nan::New("sec").ToLocalChecked(), Nan::New(sec));
-  Nan::Set(obj, Nan::New("nanosec").ToLocalChecked(), Nan::New(nanosec));
-  if (clock_type != RCL_CLOCK_UNINITIALIZED) {
-    Nan::Set(obj, Nan::New("type").ToLocalChecked(), Nan::New(type));
-  }
-
-  info.GetReturnValue().Set(obj);
-}
-
 NAN_METHOD(ClockGetNow) {
   rcl_clock_t* clock = reinterpret_cast<rcl_clock_t*>(
       RclHandle::Unwrap<RclHandle>(
@@ -569,64 +562,9 @@ NAN_METHOD(ClockGetNow) {
   THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
                            rcl_clock_get_now(clock, &time_point.nanoseconds),
                            rcl_get_error_string().str);
-
-  ReturnJSTimeObj(info, time_point.nanoseconds, time_point.clock_type);
-}
-
-NAN_METHOD(StaticClockGetNow) {
-  int32_t type = Nan::To<int32_t>(info[0]).FromJust();
-
-  if (type < RCL_ROS_TIME && type > RCL_STEADY_TIME) {
-    info.GetReturnValue().Set(Nan::Undefined());
-    return;
-  }
-
-  rcl_clock_t ros_clock;
-  rcl_time_point_t rcl_time;
-  rcl_allocator_t allocator = rcl_get_default_allocator();
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_clock_init(static_cast<rcl_clock_type_t>(type),
-                                          &ros_clock, &allocator),
-                           rcl_get_error_string().str);
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
-                           rcl_clock_get_now(&ros_clock, &rcl_time.nanoseconds),
-                           rcl_get_error_string().str);
-
-  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, rcl_clock_fini(&ros_clock),
-                           rcl_get_error_string().str);
-
-  ReturnJSTimeObj(info, rcl_time.nanoseconds, rcl_time.clock_type);
-}
-
-NAN_METHOD(TimeDiff) {
-  int64_t s_sec = Nan::To<int32_t>(info[0]).FromJust();
-  uint32_t s_nano = Nan::To<uint32_t>(info[1]).FromJust();
-  int32_t s_type = Nan::To<int32_t>(info[2]).FromJust();
-
-  int64_t f_sec = Nan::To<int32_t>(info[3]).FromJust();
-  uint32_t f_nano = Nan::To<uint32_t>(info[4]).FromJust();
-  int32_t f_type = Nan::To<int32_t>(info[5]).FromJust();
-
-  rcl_time_point_t start;
-  rcl_time_point_t finish;
-  rcl_duration_t delta;
-
-  start.nanoseconds = s_sec * 1000 * 1000 * 1000 + s_nano;
-  start.clock_type = static_cast<rcl_clock_type_t>(s_type);
-
-  finish.nanoseconds = f_sec * 1000 * 1000 * 1000 + f_nano;
-  finish.clock_type = static_cast<rcl_clock_type_t>(f_type);
-
-  auto ret = rcl_difference_times(&start, &finish, &delta);
-
-  if (ret == RCL_RET_OK) {
-    ReturnJSTimeObj(info, delta.nanoseconds);
-    return;
-  }
-
-  info.GetReturnValue().Set(Nan::Undefined());
+  v8::Local<v8::BigInt> bigInt =
+      v8::BigInt::New(v8::Isolate::GetCurrent(), time_point.nanoseconds);
+  info.GetReturnValue().Set(bigInt);
 }
 
 NAN_METHOD(RclTake) {
@@ -2051,8 +1989,6 @@ std::vector<BindingMethod> binding_methods = {
     {"timerGetTimeUntilNextCall", TimerGetTimeUntilNextCall},
     {"createClock", CreateClock},
     {"clockGetNow", ClockGetNow},
-    {"staticClockGetNow", StaticClockGetNow},
-    {"timeDiff", TimeDiff},
     {"createTimePoint", CreateTimePoint},
     {"getNanoseconds", GetNanoseconds},
     {"createDuration", CreateDuration},

package/types/duration.d.ts

@@ -10,15 +10,14 @@ declare module 'rclnodejs' {
      * @param seconds - The seconds component of the duration, default = 0.
      * @param nanoseconds - The nanoseconds component of the duration, default = 0.
      */
-    constructor(seconds?: number | string, nanoseconds?: number | string);
+    constructor(seconds?: bigint, nanoseconds?: bigint);
 
     /**
      * Get the nanosecond component of the Duration.
      *
-     * @returns The nanoseconds, if the value is greater than Number.MAX_SAFE_INTEGER (2^53-1),
-     *         will be presented in a string of decimal format.
+     * @returns The nanoseconds.
      */
-    readonly nanoseconds: number | string;
+    readonly nanoseconds: bigint;
 
     /**
      * Test if this Duration is equal to another Duration.

package/types/node.d.ts

@@ -267,7 +267,7 @@ declare module 'rclnodejs' {
      * @returns New instance of Timer.
      */
     createTimer(
-      period: number,
+      period: bigint,
       callback: TimerRequestCallback,
       clock?: Clock
     ): Timer;

package/types/time.d.ts

@@ -14,11 +14,7 @@ declare module 'rclnodejs' {
      * @param nanoseconds - The nanoseconds component of the time, default = 0.
      * @param clockType - The clock type, default = Clock.ClockType.SYSTEM_TIME
      */
-    constructor(
-      seconds?: number | string,
-      nanoseconds?: number | string,
-      clockType?: ClockType
-    );
+    constructor(seconds?: bigint, nanoseconds?: bigint, clockType?: ClockType);
 
     /**
      * Get the the clock type of the Time object.
@@ -27,15 +23,13 @@ declare module 'rclnodejs' {
 
     /**
      * Get the nanosecond part of the time.
-     * If the value is greater than Number.MAX_SAFE_INTEGER (2^53-1) it
-     * will be returned in a string of decimal format.
      */
-    readonly nanoseconds: number | string;
+    readonly nanoseconds: bigint;
 
     /**
      * Get the time as a plain JavaScript object.
      */
-    readonly secondsAndNanoseconds: { seconds: number; nanoseconds: number };
+    readonly secondsAndNanoseconds: { seconds: bigint; nanoseconds: bigint };
 
     /**
      * Add a duration to this time object.

package/types/timer.d.ts

@@ -4,9 +4,9 @@ declare module 'rclnodejs' {
    */
   interface Timer {
     /**
-     * Time between callbacks in milliseconds.
+     * Time between callbacks in nanoseconds.
      */
-    readonly period: number;
+    readonly period: bigint;
 
     /**
      * Check if the timer is ready.
@@ -35,15 +35,15 @@ declare module 'rclnodejs' {
     /**
      * Get the interval since the last call of this timer.
      *
-     * @returns The interval value in milliseconds.
+     * @returns The interval value in nanoseconds.
      */
-    timeSinceLastCall(): number;
+    timeSinceLastCall(): bigint;
 
     /**
      * Get the interval until the next call will happen.
      *
-     * @returns The interval value in milliseconds
+     * @returns The interval value in nanoseconds
      */
-    timeUntilNextCall(): number;
+    timeUntilNextCall(): bigint;
   }
 }