rclnodejs 0.29.0 → 0.31.0

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/parameter.d.ts

@@ -45,7 +45,7 @@ declare module 'rclnodejs' {
      *
      * @param name - The parameter name, must be a valid name.
      * @param type - The type identifier.
-     * @param {value - The parameter value.
+     * @param value - The parameter value.
      */
     constructor(name: string, type: ParameterType, value?: any);
 
@@ -261,16 +261,15 @@ declare module 'rclnodejs' {
   /**
    *
    */
-  class IntegerRange extends FloatingPointRange {
+  class IntegerRange extends Range {
     /**
      * Create a new instance.
      * @constructor
-     * @param {number} fromValue - The lowest inclusive value in range
-     * @param {number} toValue - The highest inclusive value in range
-     * @param {number} step - The internal unit size.
-     * @param {number} tolerance - The plus/minus tolerance for number equivalence.
+     * @param {bigint} fromValue - The lowest inclusive value in range
+     * @param {bigint} toValue - The highest inclusive value in range
+     * @param {bigint} step - The internal unit size.
      */
-    constructor(from: number, to: number, step?: number, tolerance?: number);
+    constructor(from: bigint, to: bigint, step?: bigint);
 
     /**
      * Determine if a ParameterType is compatible.

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;
   }
 }