@sentryware/s2-node 0.0.6

package/src/cell_id.cc

@@ -0,0 +1,210 @@
+#include "cell_id.h"
+
+Napi::FunctionReference CellId::constructor;
+
+Napi::Object CellId::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "CellId", {
+    InstanceMethod("id", &CellId::Id),
+    InstanceMethod("idString", &CellId::IdString),
+    InstanceMethod("token", &CellId::Token),
+    InstanceMethod("contains", &CellId::Contains),
+    InstanceMethod("intersects", &CellId::Intersects),
+    InstanceMethod("parent", &CellId::Parent),
+    InstanceMethod("child", &CellId::Child),
+    InstanceMethod("next", &CellId::Next),
+    InstanceMethod("level", &CellId::Level),
+    InstanceMethod("isLeaf", &CellId::IsLeaf),
+    InstanceMethod("rangeMin", &CellId::RangeMin),
+    InstanceMethod("rangeMax", &CellId::RangeMax),
+    StaticMethod("fromToken", &CellId::FromToken),
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("CellId", func);
+  return exports;
+}
+
+CellId::CellId(const Napi::CallbackInfo& info) : Napi::ObjectWrap<CellId>(info)  {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  int length = info.Length();
+  string badArgs = "(id: bigint) | (token: string) | (ll: LatLng) expected.";
+
+  if (
+    length <= 0
+    || (
+      !info[0].IsString()
+      && !info[0].IsObject()
+      && !info[0].IsBigInt()
+      && !info[0].IsExternal()
+    )
+  ) {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (info[0].IsString()) {         // token: string
+    Napi::String tokenString = info[0].As<Napi::String>();
+    this->s2cellid = S2CellId::FromToken(tokenString);
+    if (!this->s2cellid.is_valid()) {
+      Napi::TypeError::New(env, "Invalid token").ThrowAsJavaScriptException();
+      return;
+    }
+  } else if (info[0].IsObject()) {  // ll: s2.LatLng
+    Napi::Object object = info[0].As<Napi::Object>();
+    bool isLL = object.InstanceOf(LatLng::constructor.Value());
+    if (isLL) {
+      LatLng* ll = LatLng::Unwrap(object);
+      this->s2cellid = S2CellId(ll->Get());
+    } else {
+      Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+      return;
+    }
+} else if (info[0].IsBigInt()) { // id: int64
+  Napi::BigInt id = info[0].As<Napi::BigInt>();
+
+  bool lossless;
+  uint64_t s2id = id.Uint64Value(&lossless);
+
+  if (lossless) {
+    this->s2cellid = S2CellId(s2id);
+  } else {
+    Napi::TypeError::New(env, "S2 ID was lossy. This might be a malformed S2 ID.").ThrowAsJavaScriptException();
+    return;
+  }
+} else if (info[0].IsExternal()) { // S2CellId C++ class
+    Napi::External<S2CellId> external = info[0].As<Napi::External<S2CellId>>();
+    this->s2cellid = *external.Data();
+  }
+}
+
+Napi::Value CellId::Id(const Napi::CallbackInfo &info) {
+  return Napi::BigInt::New(info.Env(), (uint64_t) s2cellid.id());
+}
+
+Napi::Value CellId::IdString(const Napi::CallbackInfo &info) {
+  std::ostringstream idStr;
+  idStr << s2cellid.id();
+  return Napi::String::New(info.Env(), idStr.str());
+}
+
+Napi::Value CellId::Token(const Napi::CallbackInfo &info) {
+  return Napi::String::New(info.Env(), s2cellid.ToToken());
+}
+
+Napi::Value CellId::Contains(const Napi::CallbackInfo &info) {
+  bool contains = false;
+
+  if (info.Length() > 0 && info[0].IsObject()) {
+    Napi::Object object = info[0].As<Napi::Object>();
+    if (object.InstanceOf(CellId::constructor.Value())) {
+      CellId* otherCellId = CellId::Unwrap(object);
+      contains = s2cellid.contains(otherCellId->Get());
+    }
+  }
+
+  return Napi::Boolean::New(info.Env(), contains);
+}
+
+Napi::Value CellId::Intersects(const Napi::CallbackInfo &info) {
+  bool intersects = false;
+
+  if (info.Length() > 0 && info[0].IsObject()) {
+    Napi::Object object = info[0].As<Napi::Object>();
+    if (object.InstanceOf(CellId::constructor.Value())) {
+      CellId* otherCellId = CellId::Unwrap(object);
+      intersects = s2cellid.intersects(otherCellId->Get());
+    }
+  }
+
+  return Napi::Boolean::New(info.Env(), intersects);
+}
+
+Napi::Value CellId::Parent(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (s2cellid.is_face()) {
+    return info.This();
+  }
+
+  if (info.Length() <= 0 || !info[0].IsNumber()) {
+    S2CellId parent = s2cellid.parent();
+    return constructor.New({ Napi::External<S2CellId>::New(env, &parent) });
+  }
+
+  int level = info[0].As<Napi::Number>().Int32Value();
+  int finalLevel = level <= 0 ? 0 : level;
+
+  S2CellId parent = s2cellid.parent(finalLevel);
+  return constructor.New({ Napi::External<S2CellId>::New(env, &parent) });
+}
+
+Napi::Value CellId::Child(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() <= 0 || !info[0].IsNumber()) {
+    Napi::TypeError::New(info.Env(), "(position: number) expected.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Number position = info[0].As<Napi::Number>();
+  S2CellId child = s2cellid.child(position.Int32Value());
+
+  if (!child.is_valid()) {
+    return info.This();
+  }
+  return constructor.New({ Napi::External<S2CellId>::New(env, &child) });
+}
+
+Napi::Value CellId::Next(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  S2CellId next = s2cellid.next();
+
+  if (!next.is_valid()) {
+    return info.This();
+  }
+  return constructor.New({ Napi::External<S2CellId>::New(env, &next) });
+}
+
+Napi::Value CellId::Level(const Napi::CallbackInfo &info) {
+  return Napi::Number::New(info.Env(), s2cellid.level());
+}
+
+Napi::Value CellId::IsLeaf(const Napi::CallbackInfo &info) {
+  return Napi::Boolean::New(info.Env(), s2cellid.is_leaf());
+}
+
+Napi::Value CellId::FromToken(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  if (info.Length() > 0 && info[0].IsString()) {
+    Napi::String token = info[0].As<Napi::String>();
+    S2CellId cellId = S2CellId::FromToken(token);
+    if (cellId.is_valid()) {
+      return constructor.New({ Napi::External<S2CellId>::New(env, &cellId) });
+    }
+  }
+  Napi::TypeError::New(env, "(token: string) expected.").ThrowAsJavaScriptException();
+  return env.Null();
+}
+
+Napi::Value CellId::RangeMin(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  S2CellId range = s2cellid.range_min();
+  return constructor.New({ Napi::External<S2CellId>::New(env, &range) });
+}
+
+Napi::Value CellId::RangeMax(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  S2CellId range = s2cellid.range_max();
+  return constructor.New({ Napi::External<S2CellId>::New(env, &range) });
+}
+
+S2CellId CellId::Get() {
+  return s2cellid;
+}

package/src/cell_id.h

@@ -0,0 +1,44 @@
+#ifndef RADAR_CELLID
+#define RADAR_CELLID
+
+#include <napi.h>
+#include <sstream>
+
+#include "latlng.h"
+#include "s2/s2cell_id.h"
+#include "s2/util/coding/varint.h"
+
+class CellId : public Napi::ObjectWrap<CellId> {
+
+  public:
+    CellId(const Napi::CallbackInfo& info);
+
+    static Napi::FunctionReference constructor;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+    S2CellId Get();
+
+  private:
+    static Napi::Value FromToken(const Napi::CallbackInfo &info);
+
+    Napi::Value Id(const Napi::CallbackInfo &info);
+    Napi::Value IdString(const Napi::CallbackInfo &info);
+    Napi::Value Token(const Napi::CallbackInfo &info);
+
+    Napi::Value Contains(const Napi::CallbackInfo &info);
+    Napi::Value Intersects(const Napi::CallbackInfo &info);
+
+    Napi::Value Parent(const Napi::CallbackInfo &info);
+    Napi::Value Child(const Napi::CallbackInfo &info);
+    Napi::Value Next(const Napi::CallbackInfo &info);
+    Napi::Value Level(const Napi::CallbackInfo &info);
+    Napi::Value IsLeaf(const Napi::CallbackInfo &info);
+
+    Napi::Value RangeMin(const Napi::CallbackInfo &info);
+    Napi::Value RangeMax(const Napi::CallbackInfo &info);
+
+    S2CellId s2cellid;
+
+};
+
+#endif

package/src/cell_union.cc

@@ -0,0 +1,237 @@
+#include "cell_union.h"
+
+Napi::FunctionReference CellUnion::constructor;
+
+Napi::Object CellUnion::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "CellUnion", {
+    InstanceMethod("contains", &CellUnion::Contains),
+    InstanceMethod("intersects", &CellUnion::Intersects),
+    InstanceMethod("union", &CellUnion::Union),
+    InstanceMethod("intersection", &CellUnion::Intersection),
+    InstanceMethod("difference", &CellUnion::Difference),
+    InstanceMethod("ids", &CellUnion::Ids),
+    InstanceMethod("cellIds", &CellUnion::CellIds),
+    InstanceMethod("tokens", &CellUnion::Tokens),
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("CellUnion", func);
+  return exports;
+}
+
+CellUnion::CellUnion(const Napi::CallbackInfo &info) : Napi::ObjectWrap<CellUnion>(info)  {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  const int length = info.Length();
+  const string badArgs = "(cellIds: s2.CellId[]) expected.";
+
+  if (
+    length <= 0
+    || (!info[0].IsArray() && !info[0].IsExternal())
+  ) {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (info[0].IsExternal()) {
+    Napi::External<S2CellUnion> external = info[0].As<Napi::External<S2CellUnion>>();
+    if (!external.Data()->IsValid()) {
+      Napi::TypeError::New(env, "S2 cell union is invalid.").ThrowAsJavaScriptException();
+      return;
+    }
+    this->s2cellunion = *external.Data();
+  } else if (info[0].IsArray()) {
+    Napi::Array cellIdArray = info[0].As<Napi::Array>();
+    uint32_t arrayLength = cellIdArray.Length();
+    if (arrayLength <= 0) {
+      Napi::RangeError::New(env, "(cellIds: s2.CellId[]) was empty.").ThrowAsJavaScriptException();
+      return;
+    }
+
+    std::vector<S2CellId> cellIdVector;
+    for (uint32_t i = 0; i < arrayLength; i++) {
+      Napi::Value obj = cellIdArray[i];
+      if (obj.IsObject()) {
+        CellId* cellId = CellId::Unwrap(obj.As<Napi::Object>());
+        cellIdVector.push_back(cellId->Get());
+      } else if (obj.IsString()) {
+        Napi::String token = obj.As<Napi::String>();
+        cellIdVector.push_back(S2CellId::FromToken(token.Utf8Value()));
+      }
+    }
+
+    this->s2cellunion = S2CellUnion(std::move(cellIdVector));
+  }
+}
+
+S2CellUnion CellUnion::Get() {
+  return this->s2cellunion;
+}
+
+Napi::Value CellUnion::Contains(const Napi::CallbackInfo &info) {
+  const Napi::Env env = info.Env();
+  const string badArgs = "(other: s2.CellId | s2.CellUnion) expected.";
+  bool contains = false;
+
+  if (info.Length() > 0 && info[0].IsObject()) {
+    Napi::Object object = info[0].As<Napi::Object>();
+    if (object.InstanceOf(CellUnion::constructor.Value())) {
+      CellUnion* otherCellUnion = CellUnion::Unwrap(object);
+      contains = s2cellunion.Contains(otherCellUnion->Get());
+    } else if (object.InstanceOf(CellId::constructor.Value())) {
+      CellId* otherCellId = CellId::Unwrap(object);
+      contains = s2cellunion.Contains(otherCellId->Get());
+    } else {
+      Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  } else {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  return Napi::Boolean::New(env, contains);
+}
+
+Napi::Value CellUnion::Intersects(const Napi::CallbackInfo &info) {
+  const Napi::Env env = info.Env();
+  const string badArgs = "(other: s2.CellId | s2.CellUnion) expected.";
+  bool intersects = false;
+
+  if (info.Length() > 0 && info[0].IsObject()) {
+    Napi::Object object = info[0].As<Napi::Object>();
+    if (object.InstanceOf(CellUnion::constructor.Value())) {
+      CellUnion* otherCellUnion = CellUnion::Unwrap(object);
+      intersects = s2cellunion.Intersects(otherCellUnion->Get());
+    } else if (object.InstanceOf(CellId::constructor.Value())) {
+      CellId* otherCellId = CellId::Unwrap(object);
+      intersects = s2cellunion.Intersects(otherCellId->Get());
+    } else {
+      Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  } else {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  return Napi::Boolean::New(env, intersects);
+}
+
+Napi::Value CellUnion::Union(const Napi::CallbackInfo &info) {
+  const Napi::Env env = info.Env();
+  const string badArgs = "(other: s2.CellUnion) expected.";
+  S2CellUnion s2Union;
+
+  if (info.Length() > 0 && info[0].IsObject()) {
+    Napi::Object object = info[0].As<Napi::Object>();
+    if (object.InstanceOf(CellUnion::constructor.Value())) {
+      CellUnion* otherCellUnion = CellUnion::Unwrap(object);
+      s2Union = s2cellunion.Union(otherCellUnion->Get());
+    } else {
+      Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  } else {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  return constructor.New({
+    Napi::External<S2CellUnion>::New(env, &s2Union)
+  });
+}
+
+Napi::Value CellUnion::Intersection(const Napi::CallbackInfo &info) {
+  const Napi::Env env = info.Env();
+  const string badArgs = "(other: s2.CellUnion) expected.";
+  S2CellUnion s2Intersection;
+
+  if (info.Length() > 0 && info[0].IsObject()) {
+    Napi::Object object = info[0].As<Napi::Object>();
+    if (object.InstanceOf(CellUnion::constructor.Value())) {
+      CellUnion* otherCellUnion = CellUnion::Unwrap(object);
+      s2Intersection = s2cellunion.Intersection(otherCellUnion->Get());
+    } else {
+      Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  } else {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  return constructor.New({
+    Napi::External<S2CellUnion>::New(env, new S2CellUnion(s2Intersection))
+  });
+}
+
+Napi::Value CellUnion::Difference(const Napi::CallbackInfo &info) {
+  const Napi::Env env = info.Env();
+  const string badArgs = "(other: s2.CellUnion) expected.";
+  S2CellUnion s2Difference;
+
+  if (info.Length() > 0 && info[0].IsObject()) {
+    Napi::Object object = info[0].As<Napi::Object>();
+    if (object.InstanceOf(CellUnion::constructor.Value())) {
+      CellUnion* otherCellUnion = CellUnion::Unwrap(object);
+      s2Difference = s2cellunion.Difference(otherCellUnion->Get());
+    } else {
+      Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  } else {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  return constructor.New({
+    Napi::External<S2CellUnion>::New(env, &s2Difference)
+  });
+}
+
+Napi::Value CellUnion::Ids(const Napi::CallbackInfo &info) {
+  const Napi::Env env = info.Env();
+
+  uint32_t size = this->s2cellunion.size();
+  Napi::BigUint64Array returnedIds = Napi::BigUint64Array::New(env, size);
+
+  for (uint32_t i = 0; i < size; i++) {
+    S2CellId cellId = this->s2cellunion[i];
+    returnedIds[i] = cellId.id();
+  }
+
+  return returnedIds;
+}
+
+Napi::Value CellUnion::CellIds(const Napi::CallbackInfo &info) {
+  const Napi::Env env = info.Env();
+
+  uint32_t size = this->s2cellunion.size();
+  Napi::Array returnedIds = Napi::Array::New(env, size);
+
+  for (uint32_t i = 0; i < size; i++) {
+    S2CellId cellId = this->s2cellunion[i];
+    returnedIds[i] = CellId::constructor.New({ Napi::External<S2CellId>::New(env, &cellId) });
+  }
+
+  return returnedIds;
+}
+
+Napi::Value CellUnion::Tokens(const Napi::CallbackInfo &info) {
+  const Napi::Env env = info.Env();
+
+  uint32_t size = this->s2cellunion.size();
+  Napi::Array returnedTokens = Napi::Array::New(env, size);
+
+  for (uint32_t i = 0; i < size; i++) {
+    returnedTokens[i] = Napi::String::New(env, this->s2cellunion[i].ToToken());
+  }
+
+  return returnedTokens;
+}

package/src/cell_union.h

@@ -0,0 +1,34 @@
+#ifndef RADAR_CELL_UNION
+#define RADAR_CELL_UNION
+
+#include <napi.h>
+#include "cell_id.h"
+#include "s2/s2cell_union.h"
+
+class CellUnion : public Napi::ObjectWrap<CellUnion> {
+
+  public:
+    static Napi::FunctionReference constructor;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+    CellUnion(const Napi::CallbackInfo& info);
+
+    S2CellUnion Get();
+
+  private:
+    S2CellUnion s2cellunion;
+
+    Napi::Value Contains(const Napi::CallbackInfo &info);
+    Napi::Value Intersects(const Napi::CallbackInfo &info);
+
+    Napi::Value Union(const Napi::CallbackInfo &info);
+    Napi::Value Intersection(const Napi::CallbackInfo &info);
+    Napi::Value Difference(const Napi::CallbackInfo &info);
+
+    Napi::Value Ids(const Napi::CallbackInfo &info);
+    Napi::Value CellIds(const Napi::CallbackInfo &info);
+    Napi::Value Tokens(const Napi::CallbackInfo &info);
+
+};
+
+#endif

package/src/earth.cc

@@ -0,0 +1,185 @@
+#include "earth.h"
+
+Napi::FunctionReference Earth::constructor;
+
+Napi::Object Earth::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "Earth", {
+    StaticMethod("toMeters", &Earth::ToMeters),
+    StaticMethod("toKm", &Earth::ToKm),
+    StaticMethod("getRadians", &Earth::GetRadians),
+    StaticMethod("getDegrees", &Earth::GetDegrees),
+    StaticMethod("getDistanceKm", &Earth::GetDistanceKm),
+    StaticMethod("getDistanceMeters", &Earth::GetDistanceMeters),
+    StaticMethod("getInitalBearingDegrees", &Earth::GetInitalBearingDegrees),
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("Earth", func);
+  return exports;
+}
+
+Earth::Earth(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Earth>(info)  {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+}
+
+bool Earth::PreCheck(const Napi::CallbackInfo &info, S2LatLng &latlng1, S2LatLng &latlng2){
+  int length = info.Length();
+
+  if (length < 2 || !info[0].IsObject() || !info[1].IsObject()){
+    return false;
+  }
+
+  Napi::Object objectA = info[0].As<Napi::Object>();
+  bool isLatlng1 = objectA.InstanceOf(LatLng::constructor.Value());
+  if (!isLatlng1) {
+    return false;
+  }
+
+  LatLng* ll1 = LatLng::Unwrap(objectA);
+  latlng1 = ll1->Get();
+
+  Napi::Object objectB = info[1].As<Napi::Object>();
+  bool isLatlng2 = objectB.InstanceOf(LatLng::constructor.Value());
+  if (!isLatlng2) {
+    return false;
+  }
+
+  LatLng* ll2 = LatLng::Unwrap(objectB);
+  latlng2 = ll2->Get();
+
+  return true;
+}
+
+Napi::Value Earth::ToMeters(const Napi::CallbackInfo &info){
+  Napi::Env env = info.Env();
+
+  S2LatLng s2LatLngA;
+  S2LatLng s2LatLngB;
+
+  bool isValid = Earth::PreCheck(info, s2LatLngA, s2LatLngB);
+  if (!isValid){
+    Napi::TypeError::New(env, "Expected arguments (a: LatLng, b: LatLng)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  S1Angle s1Angle = S1Angle(s2LatLngA, s2LatLngB);
+  double distance = S2Earth::ToMeters(s1Angle);
+
+  return Napi::Number::New(env, distance);
+}
+
+Napi::Value Earth::ToKm(const Napi::CallbackInfo &info){
+  Napi::Env env = info.Env();
+
+  S2LatLng s2LatLngA;
+  S2LatLng s2LatLngB;
+
+  bool isValid = Earth::PreCheck(info, s2LatLngA, s2LatLngB);
+  if (!isValid){
+    Napi::TypeError::New(env, "Expected arguments (a: LatLng, b: LatLng)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  S1Angle s1Angle = S1Angle(s2LatLngA, s2LatLngB);
+
+  double distance = S2Earth::ToKm(s1Angle);
+
+  return Napi::Number::New(env, distance);
+}
+
+Napi::Value Earth::GetRadians(const Napi::CallbackInfo &info){
+  Napi::Env env = info.Env();
+
+  S2LatLng s2LatLngA;
+  S2LatLng s2LatLngB;
+
+  bool isValid = Earth::PreCheck(info, s2LatLngA, s2LatLngB);
+  if (!isValid) {
+    Napi::TypeError::New(env, "Expected arguments (a: LatLng, b: LatLng)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  S1Angle s1Angle = S1Angle(s2LatLngA, s2LatLngB);
+
+  double radians = s1Angle.radians();
+  return Napi::Number::New(env, radians);
+}
+
+Napi::Value Earth::GetDegrees(const Napi::CallbackInfo &info){
+  Napi::Env env = info.Env();
+
+  S2LatLng s2LatLngA;
+  S2LatLng s2LatLngB;
+
+  bool isValid = Earth::PreCheck(info, s2LatLngA, s2LatLngB);
+  if (!isValid){
+    Napi::TypeError::New(env, "Expected arguments (a: LatLng, b: LatLng)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  S1Angle s1Angle = S1Angle(s2LatLngA, s2LatLngB);
+
+  double degrees = s1Angle.degrees();
+  return Napi::Number::New(env, degrees);
+}
+
+Napi::Value Earth::GetDistanceKm(const Napi::CallbackInfo &info){
+  Napi::Env env = info.Env();
+
+  S2LatLng s2LatLngA;
+  S2LatLng s2LatLngB;
+
+  bool isValid = Earth::PreCheck(info, s2LatLngA, s2LatLngB);
+  if (!isValid){
+    Napi::TypeError::New(env, "Expected arguments (a: LatLng, b: LatLng)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  double distance = S2Earth::GetDistanceKm(s2LatLngA, s2LatLngB);
+
+  return Napi::Number::New(env, distance);
+}
+
+Napi::Value Earth::GetDistanceMeters(const Napi::CallbackInfo &info){
+  Napi::Env env = info.Env();
+
+  S2LatLng s2LatLngA;
+  S2LatLng s2LatLngB;
+
+  bool isValid = Earth::PreCheck(info, s2LatLngA, s2LatLngB);
+  if (!isValid){
+    Napi::TypeError::New(env, "Expected arguments (a: LatLng, b: LatLng)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  double distance = S2Earth::GetDistanceMeters(s2LatLngA, s2LatLngB);
+
+  return Napi::Number::New(env, distance);
+}
+
+Napi::Value Earth::GetInitalBearingDegrees(const Napi::CallbackInfo &info){
+  Napi::Env env = info.Env();
+
+  S2LatLng s2LatLngA;
+  S2LatLng s2LatLngB;
+
+  bool isValid = Earth::PreCheck(info, s2LatLngA, s2LatLngB);
+  if (!isValid){
+    Napi::TypeError::New(env, "Expected arguments (a: LatLng, b: LatLng)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  S1Angle s1Angle = S2Earth::GetInitialBearing(s2LatLngA, s2LatLngB);
+
+  double degrees = s1Angle.degrees();
+  return Napi::Number::New(env, degrees);
+}
+
+S2Earth Earth::Get() {
+  return this->s2earth;
+}