@sentryware/s2-node 0.0.6

package/src/region_coverer.cc

@@ -0,0 +1,450 @@
+#include "region_coverer.h"
+
+using absl::make_unique;
+
+Napi::FunctionReference RegionCoverer::constructor;
+
+Napi::Object RegionCoverer::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func = DefineClass(env, "RegionCoverer", {
+    StaticMethod("getCovering", &RegionCoverer::GetCoveringCellUnion),
+    StaticMethod("getCoveringIds", &RegionCoverer::GetCoveringIds),
+    StaticMethod("getCoveringTokens", &RegionCoverer::GetCoveringTokens),
+
+    StaticMethod("getRadiusCovering", &RegionCoverer::GetRadiusCoveringCellUnion),
+    StaticMethod("getRadiusCoveringIds", &RegionCoverer::GetRadiusCoveringIds),
+    StaticMethod("getRadiusCoveringTokens", &RegionCoverer::GetRadiusCoveringTokens),
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+
+  exports.Set("RegionCoverer", func);
+  return exports;
+}
+
+RegionCoverer::RegionCoverer(const Napi::CallbackInfo& info) : Napi::ObjectWrap<RegionCoverer>(info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+}
+
+Napi::Value RegionCoverer::GetCoveringIds(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  int length = info.Length();
+  string badArgs = "(latlngs: s2.LatLng[], options: { min?: number, max?: number, max_cells?: number }) expected.";
+
+  if (length <= 1 || !info[0].IsArray() || !info[1].IsObject()) {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Array llArray = info[0].As<Napi::Array>();
+  uint32_t arrayLength = llArray.Length();
+  if (arrayLength <= 0) {
+    Napi::TypeError::New(env, "(latlngs: s2.LatLng[]) was empty.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object optionsObject = info[1].As<Napi::Object>();
+  S2RegionCoverer::Options options;
+  GetS2Options(optionsObject, options);
+
+  std::vector<S2Point> vertices;
+  for (uint32_t i = 0; i < arrayLength; i++) {
+    Napi::Value obj = llArray[i];
+    if (obj.IsObject()) {
+      LatLng* ll = LatLng::Unwrap(obj.As<Napi::Object>());
+      S2Point point = ll->Get().Normalized().ToPoint().Normalize();
+      vertices.push_back(point);
+    } else {
+      Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  }
+
+  S2Error loopError;
+  S2Error buildError;
+  S2Error outputError;
+
+  S2CellUnion covering = GetCovering(
+    env,
+    vertices,
+    options,
+    loopError,
+    buildError,
+    outputError
+  );
+
+  if (!loopError.ok()) {
+    Napi::Error::New(
+      env,
+      StringPrintf("Loop is invalid: %d %s", loopError.code(), loopError.text().c_str())
+    ).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!buildError.ok()) {
+    Napi::Error::New(
+      env,
+      StringPrintf("Build failed: %d %s", buildError.code(), buildError.text().c_str())
+    ).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!outputError.ok()) {
+    Napi::Error::New(
+      env,
+      StringPrintf("Output is invalid: %d %s", outputError.code(), outputError.text().c_str())
+    ).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!covering.IsValid()) {
+    Napi::Error::New(env, "Covering is invalid").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  uint32_t size = covering.size();
+  Napi::BigUint64Array returnedIds = Napi::BigUint64Array::New(env, size);
+
+  for (uint32_t i = 0; i < size; i++) {
+    returnedIds[i] = covering[i].id();
+  }
+
+  return returnedIds;
+}
+
+Napi::Value RegionCoverer::GetCoveringTokens(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  int length = info.Length();
+  string badArgs = "(latlngs: s2.LatLng[], options: { min?: number, max?: number, max_cells?: number }) expected.";
+
+  if (length <= 1 || !info[0].IsArray() || !info[1].IsObject()) {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Array llArray = info[0].As<Napi::Array>();
+  uint32_t arrayLength = llArray.Length();
+  if (arrayLength <= 0) {
+    Napi::TypeError::New(env, "(latlngs: s2.LatLng[]) was empty.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object optionsObject = info[1].As<Napi::Object>();
+  S2RegionCoverer::Options options;
+  GetS2Options(optionsObject, options);
+
+  std::vector<S2Point> vertices;
+  for (uint32_t i = 0; i < arrayLength; i++) {
+    Napi::Value obj = llArray[i];
+    if (obj.IsObject()) {
+      LatLng* ll = LatLng::Unwrap(obj.As<Napi::Object>());
+      S2Point point = ll->Get().Normalized().ToPoint().Normalize();
+      vertices.push_back(point);
+    } else {
+      Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  }
+
+  S2Error loopError;
+  S2Error buildError;
+  S2Error outputError;
+
+  S2CellUnion covering = GetCovering(
+    env,
+    vertices,
+    options,
+    loopError,
+    buildError,
+    outputError
+  );
+
+  if (!loopError.ok()) {
+    Napi::Error::New(
+      env,
+      StringPrintf("Loop is invalid: %d %s", loopError.code(), loopError.text().c_str())
+    ).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!buildError.ok()) {
+    Napi::Error::New(
+      env,
+      StringPrintf("Build failed: %d %s", buildError.code(), buildError.text().c_str())
+    ).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!outputError.ok()) {
+    Napi::Error::New(
+      env,
+      StringPrintf("Output is invalid: %d %s", outputError.code(), outputError.text().c_str())
+    ).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!covering.IsValid()) {
+    Napi::Error::New(env, "Covering is invalid").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  uint32_t size = covering.size();
+  Napi::Array returnedIds = Napi::Array::New(env, size);
+
+  for (uint32_t i = 0; i < size; i++) {
+    returnedIds[i] = Napi::String::New(env, covering[i].ToToken());
+  }
+
+  return returnedIds;
+}
+
+Napi::Value RegionCoverer::GetCoveringCellUnion(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  int length = info.Length();
+  string badArgs = "(latlngs: s2.LatLng[], options: { min?: number, max?: number, max_cells?: number }) expected.";
+
+  if (length <= 1 || !info[0].IsArray() || !info[1].IsObject()) {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Array llArray = info[0].As<Napi::Array>();
+  uint32_t arrayLength = llArray.Length();
+  if (arrayLength <= 0) {
+    Napi::TypeError::New(env, "(latlngs: s2.LatLng[]) was empty.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object optionsObject = info[1].As<Napi::Object>();
+  S2RegionCoverer::Options options;
+  GetS2Options(optionsObject, options);
+
+  std::vector<S2Point> vertices;
+  for (uint32_t i = 0; i < arrayLength; i++) {
+    Napi::Value obj = llArray[i];
+    if (obj.IsObject()) {
+      LatLng* ll = LatLng::Unwrap(obj.As<Napi::Object>());
+      S2Point point = ll->Get().Normalized().ToPoint().Normalize();
+      vertices.push_back(point);
+    } else {
+      Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  }
+
+  S2Error loopError;
+  S2Error buildError;
+  S2Error outputError;
+
+  S2CellUnion covering = GetCovering(
+    env,
+    vertices,
+    options,
+    loopError,
+    buildError,
+    outputError
+  );
+
+  if (!loopError.ok()) {
+    Napi::Error::New(
+      env,
+      StringPrintf("Loop is invalid: %d %s", loopError.code(), loopError.text().c_str())
+    ).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!buildError.ok()) {
+    Napi::Error::New(
+      env,
+      StringPrintf("Build failed: %d %s", buildError.code(), buildError.text().c_str())
+    ).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!outputError.ok()) {
+    Napi::Error::New(
+      env,
+      StringPrintf("Output is invalid: %d %s", outputError.code(), outputError.text().c_str())
+    ).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!covering.IsValid()) {
+    Napi::Error::New(env, "Covering is invalid").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  return CellUnion::constructor.New({
+    Napi::External<S2CellUnion>::New(env, &covering)
+  });
+}
+
+Napi::Value RegionCoverer::GetRadiusCoveringTokens(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  int length = info.Length();
+  string badArgs = "(latlng: s2.LatLng, radiusM: number, options: { min?: number, max?: number, max_cells?: number }) expected.";
+
+  if (
+    length < 3
+    || !info[0].IsObject()
+    || !info[1].IsNumber()
+    || !info[2].IsObject()
+  ) {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object optionsObject = info[2].As<Napi::Object>();
+  S2RegionCoverer::Options options;
+  GetS2Options(optionsObject, options);
+
+  LatLng* ll = LatLng::Unwrap(info[0].As<Napi::Object>());
+  double radiusM = info[1].As<Napi::Number>().DoubleValue();
+
+  S2CellUnion covering = GetRadiusCovering(ll, radiusM, options);
+
+  uint32_t size = covering.size();
+  Napi::Array returnedIds = Napi::Array::New(env, size);
+
+  for (uint32_t i = 0; i < size; i++) {
+    returnedIds[i] = Napi::String::New(env, covering[i].ToToken());
+  }
+
+  return returnedIds;
+}
+
+Napi::Value RegionCoverer::GetRadiusCoveringIds(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  int length = info.Length();
+  string badArgs = "(latlng: s2.LatLng, radiusM: number, options: { min?: number, max?: number, max_cells?: number }) expected.";
+
+  if (
+    length < 3
+    || !info[0].IsObject()
+    || !info[1].IsNumber()
+    || !info[2].IsObject()
+  ) {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object optionsObject = info[2].As<Napi::Object>();
+  S2RegionCoverer::Options options;
+  GetS2Options(optionsObject, options);
+
+  LatLng* ll = LatLng::Unwrap(info[0].As<Napi::Object>());
+  double radiusM = info[1].As<Napi::Number>().DoubleValue();
+
+  S2CellUnion covering = GetRadiusCovering(ll, radiusM, options);
+
+  uint32_t size = covering.size();
+  Napi::BigUint64Array returnedIds = Napi::BigUint64Array::New(env, size);
+
+  for (uint32_t i = 0; i < size; i++) {
+    returnedIds[i] = covering[i].id();
+  }
+
+  return returnedIds;
+}
+
+Napi::Value RegionCoverer::GetRadiusCoveringCellUnion(const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+
+  int length = info.Length();
+  string badArgs = "(latlng: s2.LatLng, radiusM: number, options: { min?: number, max?: number, max_cells?: number }) expected.";
+
+  if (
+    length < 3
+    || !info[0].IsObject()
+    || !info[1].IsNumber()
+    || !info[2].IsObject()
+  ) {
+    Napi::TypeError::New(env, badArgs).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object optionsObject = info[2].As<Napi::Object>();
+  S2RegionCoverer::Options options;
+  GetS2Options(optionsObject, options);
+
+  LatLng* ll = LatLng::Unwrap(info[0].As<Napi::Object>());
+  double radiusM = info[1].As<Napi::Number>().DoubleValue();
+
+  S2CellUnion covering = GetRadiusCovering(ll, radiusM, options);
+  return CellUnion::constructor.New({
+    Napi::External<S2CellUnion>::New(env, &covering)
+  });
+}
+
+void RegionCoverer::GetS2Options(
+  Napi::Object optionsObject,
+  S2RegionCoverer::Options &options
+) {
+  Napi::Value minLevelRaw = optionsObject["min"];
+  Napi::Value maxLevelRaw = optionsObject["max"];
+  Napi::Value maxCellsRaw = optionsObject["max_cells"];
+
+  if (minLevelRaw.IsNumber()) {
+    options.set_min_level(minLevelRaw.As<Napi::Number>().Uint32Value());
+  }
+  if (maxLevelRaw.IsNumber()) {
+    options.set_max_level(maxLevelRaw.As<Napi::Number>().Uint32Value());
+  }
+  if (maxCellsRaw.IsNumber()) {
+    options.set_max_cells(maxCellsRaw.As<Napi::Number>().Uint32Value());
+  }
+}
+
+S2CellUnion RegionCoverer::GetCovering(
+  Napi::Env env,
+  std::vector<S2Point> &vertices,
+  S2RegionCoverer::Options &coverOptions,
+  S2Error &loopError,
+  S2Error &buildError,
+  S2Error &outputError
+) {
+  S2Loop loop(vertices, S2Debug::ALLOW);
+  loop.Normalize();
+
+  bool loopOk = !loop.FindValidationError(&loopError);
+  if (!loopOk) { return S2CellUnion(); }
+
+  S2Builder::Options builderOptions;
+  S2Builder builder(builderOptions);
+
+  S2Polygon output;
+  builder.StartLayer(std::make_unique<s2builderutil::S2PolygonLayer>(&output));
+  builder.AddLoop(loop);
+
+  bool buildOk = builder.Build(&buildError);
+  if (!buildOk) { return S2CellUnion(); }
+
+  bool outputOk = !output.FindValidationError(&outputError);
+  if (!outputOk) { return S2CellUnion(); }
+
+  S2RegionCoverer coverer(coverOptions);
+  return coverer.GetCovering(output);
+}
+
+S2CellUnion RegionCoverer::GetRadiusCovering(
+  LatLng* ll,
+  double radiusM,
+  S2RegionCoverer::Options &coverOptions
+) {
+  S2Point point = ll->Get().Normalized().ToPoint().Normalize();
+  S1Angle angle = S1Angle::Radians(S2Earth::MetersToRadians(radiusM));
+  S2Cap s2cap(point, angle);
+  if (!s2cap.is_valid()) {
+    return S2CellUnion();
+  }
+  S2RegionCoverer coverer(coverOptions);
+  return coverer.GetCovering(s2cap);
+}

package/src/region_coverer.h

@@ -0,0 +1,56 @@
+#ifndef RADAR_REGION_COVERER
+#define RADAR_REGION_COVERER
+
+#include <napi.h>
+#include "polygon.h"
+#include "cell_id.h"
+#include "cell_union.h"
+#include "s2/s1angle.h"
+#include "s2/s2builder.h"
+#include "s2/s2builderutil_s2polygon_layer.h"
+#include "s2/s2cap.h"
+#include "s2/s2cell_union.h"
+#include "s2/s2earth.h"
+#include "s2/s2polygon.h"
+#include "s2/s2region_coverer.h"
+#include "s2/third_party/absl/memory/memory.h"
+
+class RegionCoverer : public Napi::ObjectWrap<RegionCoverer> {
+
+  public:
+    static Napi::FunctionReference constructor;
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+    RegionCoverer(const Napi::CallbackInfo& info);
+
+  private:
+    static Napi::Value GetCoveringIds(const Napi::CallbackInfo &info);
+    static Napi::Value GetCoveringTokens(const Napi::CallbackInfo &info);
+    static Napi::Value GetCoveringCellUnion(const Napi::CallbackInfo &info);
+
+    static Napi::Value GetRadiusCoveringIds(const Napi::CallbackInfo &info);
+    static Napi::Value GetRadiusCoveringTokens(const Napi::CallbackInfo &info);
+    static Napi::Value GetRadiusCoveringCellUnion(const Napi::CallbackInfo &info);
+
+    static void GetS2Options(
+      Napi::Object optionsObject,
+      S2RegionCoverer::Options &options
+    );
+
+    static S2CellUnion GetCovering(
+      Napi::Env env,
+      std::vector<S2Point> &vertices,
+      S2RegionCoverer::Options &coverOptions,
+      S2Error &loopError,
+      S2Error &buildError,
+      S2Error &outputError
+    );
+
+    static S2CellUnion GetRadiusCovering(
+      LatLng* ll,
+      double radiusM,
+      S2RegionCoverer::Options &coverOptions
+    );
+};
+
+#endif

package/src/s2.cc

@@ -0,0 +1,27 @@
+#include "builder.h"
+#include "cell.h"
+#include "cell_id.h"
+#include "cell_union.h"
+#include "earth.h"
+#include "latlng.h"
+#include "loop.h"
+#include "point.h"
+#include "polygon.h"
+#include "polyline.h"
+#include "region_coverer.h"
+
+Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
+  Builder::Init(env, exports);
+  Cell::Init(env, exports);
+  CellId::Init(env, exports);
+  Earth::Init(env, exports);
+  LatLng::Init(env, exports);
+  Loop::Init(env, exports);
+  Point::Init(env, exports);
+  Polygon::Init(env, exports);
+  Polyline::Init(env, exports);
+  CellUnion::Init(env, exports);
+  return RegionCoverer::Init(env, exports);
+}
+
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, InitAll)

package/test/Cell.test.js

@@ -0,0 +1,37 @@
+// magic incantation from step 3 @ https://github.com/mapbox/node-pre-gyp#readme
+const binary = require('@mapbox/node-pre-gyp');
+const path = require('path');
+var binding_path = binary.find(path.resolve('./package.json'));
+const s2 = require(binding_path);
+
+test("Cell#constructor accepts cellId", () => {
+  const id = 6924439526941130752n;
+  const cellId = new s2.CellId(id);
+  const cell = new s2.Cell(cellId);
+  expect(cell.constructor).toBe(s2.Cell);
+});
+
+test("Cell#getVertex returns Point for vertex position", () => {
+  const id = 6924439526941130752n;
+  const cellId = new s2.CellId(id);
+  const cell = new s2.Cell(cellId);
+
+  const v1 = cell.getVertex(0);
+  const v2 = cell.getVertex(1);
+  const v3 = cell.getVertex(2);
+  const v4 = cell.getVertex(3);
+
+  expect([v1.x(), v1.y(), v1.z()]).toEqual([-0.6193073896908822, 0.5249960533039503, 0.5838128990434704]);
+  expect([v2.x(), v2.y(), v2.z()]).toEqual([-0.6194499844134254, 0.5251169329637175, 0.5835528455289937]);
+  expect([v3.x(), v3.y(), v3.z()]).toEqual([-0.6195734250744275, 0.5248419898946621, 0.5836691328012421]);
+  expect([v4.x(), v4.y(), v4.z()]).toEqual([-0.6194307451080033, 0.5247211253861704, 0.583929184566429]);
+});
+
+test("Cell#getCenter returns Point for center position", () => {
+  const id = 6924439526941130752n;
+  const cellId = new s2.CellId(id);
+  const cell = new s2.Cell(cellId);
+
+  const center = cell.getCenter();
+  expect([center.x(), center.y(), center.z()]).toEqual([-0.6194403961888982, 0.5249190405535087, 0.5837410354204379]);
+});

package/test/CellId.test.js

@@ -0,0 +1,135 @@
+// magic incantation from step 3 @ https://github.com/mapbox/node-pre-gyp#readme
+const binary = require('@mapbox/node-pre-gyp');
+const path = require('path');
+var binding_path = binary.find(path.resolve('./package.json'));
+const s2 = require(binding_path);
+
+const tokyoTower = [35.6586, 139.7454];
+
+
+test("CellId#constructor accepts id: bigint", () => {
+  const id = 6924439526941130752n;
+  const cellId = new s2.CellId(id);
+  expect(cellId.id()).toBe(6924439526941130752n);
+  expect(cellId.idString()).toBe('6924439526941130752');
+  expect(cellId.token()).toBe('60188d1');
+  expect(cellId.level()).toBe(12);
+});
+
+test("CellId#constructor accepts ll: LatLng", () => {
+  const cellId = new s2.CellId(new s2.LatLng(...tokyoTower));
+  expect(cellId.id()).toBe(6924438073539270971n);
+  expect(cellId.idString()).toBe('6924438073539270971');
+  expect(cellId.token()).toBe('60188bbd9a7f993b');
+  expect(cellId.level()).toBe(30);
+});
+
+test('CellId#constructor accepts token: string', () => {
+  const cellId = new s2.CellId('89c258c');
+  expect(cellId.id()).toBe(9926594110334959616n);
+  expect(cellId.idString()).toBe('9926594110334959616');
+  expect(cellId.token()).toBe('89c258c');
+  expect(cellId.level()).toBe(11);
+});
+
+test('CellId#FromToken works', () => {
+  const cellId = s2.CellId.fromToken('89c258c');
+  expect(cellId.id()).toBe(9926594110334959616n);
+  expect(cellId.idString()).toBe('9926594110334959616');
+  expect(cellId.token()).toBe('89c258c');
+  expect(cellId.level()).toBe(11);
+});
+
+test("CellId#intersects works", () => {
+  const intersecting1 = s2.CellId.fromToken('89c2584');
+  const intersecting2 = s2.CellId.fromToken('89c259');
+  const outside1 = s2.CellId.fromToken('89c258c');
+
+  expect(intersecting1.intersects(intersecting2)).toBe(true);
+  expect(intersecting1.intersects(outside1)).toBe(false);
+
+  // parent relationship
+  expect(intersecting1.parent().intersects(intersecting1)).toBe(true);
+});
+
+test("CellId#contains works", () => {
+  const parent = new s2.CellId(6924438358710026240n);
+  const child = new s2.CellId(6924439526941130752n);
+
+  expect(parent.contains(child)).toBe(true);
+  expect(child.contains(parent)).toBe(false);
+
+  // parent relationship
+  expect(child.parent().contains(child)).toBe(true);
+});
+
+test("CellId#parent works", () => {
+  const parent = new s2.CellId(6924438358710026240n);
+  const child = new s2.CellId(6924439526941130752n);
+
+  // check basic child-parent relationships
+  const parentId = child.parent(parent.level()).id();
+  expect(parentId).toBe(parent.id());
+  expect(child.level()).toBe(12);
+  expect(child.parent().level()).toBe(11);
+
+  // level-0 cell parent should return the same cell
+  const topLevelCell = s2.CellId.fromToken('9');
+  expect(topLevelCell.level()).toBe(0);
+
+  expect(topLevelCell.parent().token()).toBe('9');
+  expect(topLevelCell.parent().level()).toBe(0);
+
+  expect(topLevelCell.parent(-1).token()).toBe('9');
+  expect(topLevelCell.parent(-1).level()).toBe(0);
+});
+
+test("CellId#child works", () => {
+  const parent = new s2.CellId(12281386552583520256n);
+
+  expect(parent.level()).toBe(7);
+  expect(parent.child(0).id()).toBe(12281333776025387008n);
+  expect(parent.child(0).level()).toBe(8);
+  expect(parent.contains(parent.child(0))).toBe(true);
+
+  expect(parent.child(1).id()).toBe(12281368960397475840n);
+  expect(parent.child(1).level()).toBe(8);
+  expect(parent.contains(parent.child(1))).toBe(true);
+
+  expect(parent.child(2).id()).toBe(12281404144769564672n);
+  expect(parent.child(2).level()).toBe(8);
+  expect(parent.contains(parent.child(2))).toBe(true);
+
+  expect(parent.child(3).id()).toBe(12281439329141653504n);
+  expect(parent.child(3).level()).toBe(8);
+  expect(parent.contains(parent.child(3))).toBe(true);
+
+  // no further children after leaf
+  const leaf = new s2.CellId(new s2.LatLng(...tokyoTower));
+  expect(leaf.id()).toBe(6924438073539270971n);
+  expect(leaf.level()).toBe(30);
+  expect(leaf.isLeaf()).toBe(true);
+  expect(leaf.child(0).id()).toBe(6924438073539270971n);
+  expect(leaf.child(0).level()).toBe(30);
+});
+
+test("CellId#next works", () => {
+  const cellId = new s2.CellId(6924439526941130752n);
+  expect(cellId.next().id()).toBe(6924439664380084224n);
+});
+
+test("CellId#isLeaf works", () => {
+  const cellId = new s2.CellId(6924439526941130752n);
+  expect(cellId.isLeaf()).toBe(false);
+  expect(cellId.parent(30).isLeaf()).toBe(true);
+});
+
+test("CellId#rangeMin works", () => {
+  const cell = new s2.CellId(6924439526941130752n);
+  expect(cell.rangeMin().id()).toBe(6924439458221654017n)
+});
+
+test("CellId#rangeMax works", () => {
+  const cell = new s2.CellId(6924439526941130752n);
+  expect(cell.rangeMax().id()).toBe(6924439595660607487n)
+});