Add neon::types::JsMap

crates/neon/src/prelude.rs

@@ -9,7 +9,7 @@ pub use crate::{
     types::{
         boxed::{Finalize, JsBox},
         JsArray, JsArrayBuffer, JsBigInt64Array, JsBigUint64Array, JsBoolean, JsBuffer, JsError,
-        JsFloat32Array, JsFloat64Array, JsFunction, JsInt16Array, JsInt32Array, JsInt8Array,
+        JsFloat32Array, JsFloat64Array, JsFunction, JsInt16Array, JsInt32Array, JsInt8Array, JsMap,
         JsNull, JsNumber, JsObject, JsPromise, JsString, JsTypedArray, JsUint16Array,
         JsUint32Array, JsUint8Array, JsUndefined, JsValue, Value,
     },

crates/neon/src/sys/bindings/functions.rs

@@ -51,6 +51,9 @@ mod napi1 {
 
             fn close_handle_scope(env: Env, scope: HandleScope) -> Status;
 
+            fn instanceof(env: Env, object: Value, constructor: Value, result: *mut bool)
+                -> Status;
+
             fn is_arraybuffer(env: Env, value: Value, result: *mut bool) -> Status;
             fn is_typedarray(env: Env, value: Value, result: *mut bool) -> Status;
             fn is_buffer(env: Env, value: Value, result: *mut bool) -> Status;

crates/neon/src/types_impl/map.rs

@@ -0,0 +1,170 @@
+use crate::{
+    context::{internal::Env, Context, Cx}, handle::{internal::TransparentNoCopyWrapper, Handle, Root}, object::Object, result::{JsResult, NeonResult}, sys::raw, thread::LocalKey, types::{private, JsFunction, JsObject, Value}
+};
+
+use super::extract::{TryFromJs, TryIntoJs};
+
+#[derive(Debug)]
+#[repr(transparent)]
+/// The type of JavaScript
+/// [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)
+/// objects.
+pub struct JsMap(raw::Local);
+
+impl JsMap {
+    pub fn new<'cx>(cx: &mut Cx<'cx>) -> NeonResult<Handle<'cx, Self>> {
+        let map = cx
+            .global::<JsFunction>("Map")?
+            .construct_with(cx)
+            .apply::<JsObject, _>(cx)?;
+
+        Ok(map.downcast_or_throw(cx)?)
+    }
+
+    pub fn size(&self, cx: &mut Cx) -> NeonResult<f64> {
+        self.prop(cx, "size").get()
+    }
+
+    pub fn clear(&self, cx: &mut Cx) -> NeonResult<()> {
+        self.method(cx, "clear")?.call()
+    }
+
+    pub fn delete<'cx, K>(
+        &self,
+        cx: &mut Cx<'cx>,
+        key: K,
+    ) -> NeonResult<bool>
+    where K: TryIntoJs<'cx> {
+        self.method(cx, "delete")?.arg(key)?.call()
+    }
+
+    pub fn entries<'cx, R>(&self, cx: &mut Cx<'cx>) -> NeonResult<R>
+    where R: TryFromJs<'cx>
+    {
+        self.method(cx, "entries")?.call()
+    }
+
+    pub fn for_each<'cx, F, R>(
+        &self,
+        cx: &mut Cx<'cx>,
+        cb: F,
+    ) -> NeonResult<R>
+    where F: TryIntoJs<'cx>, R: TryFromJs<'cx>
+    {
+        self.method(cx, "forEach")?.arg(cb)?.call()
+    }
+
+    pub fn get<'cx, K, R>(
+        &self,
+        cx: &mut Cx<'cx>,
+        key: K,
+    ) -> NeonResult<R>
+    where
+        K: TryIntoJs<'cx>,
+        R: TryFromJs<'cx>
+    {
+        self.method(cx, "get")?.arg(key)?.call()
+    }
+
+    pub fn has<'cx, K>(
+        &self,
+        cx: &mut Cx<'cx>,
+        key: K,
+    ) -> NeonResult<bool>
+    where
+        K: TryIntoJs<'cx>,
+    {
+        self.method(cx, "has")?.arg(key)?.call()
+    }
+
+    pub fn keys<'cx, R>(&self, cx: &mut Cx<'cx>) -> NeonResult<R>
+    where
+        R: TryFromJs<'cx>
+    {
+        self.method(cx, "keys")?.call()
+    }
+
+    pub fn set<'cx, K, V>(
+        &self,
+        cx: &mut Cx<'cx>,
+        key: K,
+        value: V,
+    ) -> NeonResult<Handle<'cx, JsMap>>
+    where
+        K: TryIntoJs<'cx>,
+        V: TryIntoJs<'cx>
+    {
+        self.method(cx, "set")?.arg(key)?.arg(value)?.call()
+    }
+
+    pub fn values<'cx, R>(&self, cx: &mut Cx<'cx>) -> NeonResult<R>
+    where
+        R: TryFromJs<'cx>
+    {
+        self.method(cx, "values")?.call()
+    }
+
+    pub fn group_by<'cx, A, B, R>(
+        cx: &mut Cx<'cx>,
+        elements: A,
+        cb: B,
+    ) -> NeonResult<R>
+    where
+        A: TryIntoJs<'cx>,
+        B: TryIntoJs<'cx>,
+        R: TryFromJs<'cx>
+    {
+        // TODO: This is broken and leads to a `failed to downcast any to object` error
+        // when trying to downcast `Map.groupBy` into a `JsFunction`...
+        cx.global::<JsObject>("Map")?
+            .method(cx, "groupBy")?
+            .arg(elements)?
+            .arg(cb)?
+            .call()
+    }
+}
+
+unsafe impl TransparentNoCopyWrapper for JsMap {
+    type Inner = raw::Local;
+
+    fn into_inner(self) -> Self::Inner {
+        self.0
+    }
+}
+
+impl private::ValueInternal for JsMap {
+    fn name() -> &'static str {
+        "Map"
+    }
+
+    fn is_typeof<Other: Value>(env: Env, other: &Other) -> bool {
+        Cx::with_context(env, |mut cx| {
+            let ctor = map_constructor(&mut cx).unwrap();
+            other.instance_of(&mut cx, &*ctor)
+        })
+    }
+
+    fn to_local(&self) -> raw::Local {
+        self.0
+    }
+
+    unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
+        Self(h)
+    }
+}
+
+impl Value for JsMap {}
+
+impl Object for JsMap {}
+
+fn global_map_constructor<'cx>(cx: &mut Cx<'cx>) -> JsResult<'cx, JsFunction> {
+    cx.global::<JsFunction>("Map")
+}
+
+fn map_constructor<'cx>(cx: &mut Cx<'cx>) -> JsResult<'cx, JsFunction> {
+    static MAP_CONSTRUCTOR: LocalKey<Root<JsFunction>> = LocalKey::new();
+
+    MAP_CONSTRUCTOR
+         .get_or_try_init(cx, |cx| global_map_constructor(cx).map(|f| f.root(cx)))
+         .map(|f| f.to_inner(cx))
+}

crates/neon/src/types_impl/mod.rs

@@ -10,6 +10,7 @@ pub(crate) mod date;
 pub(crate) mod error;
 pub mod extract;
 pub mod function;
+pub(crate) mod map;
 pub(crate) mod promise;
 
 pub(crate) mod private;
@@ -24,7 +25,7 @@ use private::prepare_call;
 use smallvec::smallvec;
 
 use crate::{
-    context::{internal::Env, Context, Cx, FunctionContext},
+    context::{internal::{ContextInternal, Env}, Context, Cx, FunctionContext},
     handle::{
         internal::{SuperType, TransparentNoCopyWrapper},
         Handle,
@@ -47,6 +48,7 @@ pub use self::{
         JsUint8Array,
     },
     error::JsError,
+    map::JsMap,
     promise::{Deferred, JsPromise},
 };
 
@@ -98,6 +100,15 @@ pub trait Value: ValueInternal {
         JsValue::new_internal(self.to_local())
     }
 
+    fn instance_of<V: Value>(&self, cx: &mut Cx, ctor: &V) -> bool {
+        let mut result = false;
+        assert_eq!(
+            unsafe { sys::bindings::instanceof(cx.env().to_raw(), self.to_local(), ctor.to_local(), &mut result) },
+            sys::bindings::Status::Ok
+        );
+        result
+    }
+
     #[cfg(feature = "sys")]
     #[cfg_attr(docsrs, doc(cfg(feature = "sys")))]
     /// Get a raw reference to the wrapped Node-API value.

test/napi/lib/map.js

@@ -0,0 +1,151 @@
+var addon = require("..");
+var assert = require("chai").assert;
+
+describe("JsMap", function () {
+  it("return a JsMap built in Rust", function () {
+    assert.deepEqual(new Map(), addon.return_js_map());
+  });
+
+  it("return a JsMap with a number as keys and values", function () {
+    assert.deepEqual(
+      new Map([
+        [1, 1000],
+        [-1, -1000],
+      ]),
+      addon.return_js_map_with_number_as_keys_and_values()
+    );
+  });
+
+  it("return a JsMap with heterogeneous keys/values", function () {
+    assert.deepEqual(
+      new Map([
+        ["a", 1],
+        [26, "z"],
+      ]),
+      addon.return_js_map_with_heterogeneous_keys_and_values()
+    );
+  });
+
+  it("can read from a JsMap", function () {
+    const map = new Map([
+      [1, "a"],
+      [2, "b"],
+    ]);
+    assert.strictEqual(addon.read_js_map(map, 2), "b");
+  });
+
+  it("can get size from a JsMap", function () {
+    const map = new Map([
+      [1, "a"],
+      [2, "b"],
+    ]);
+    assert.strictEqual(addon.get_js_map_size(map), 2);
+    assert.strictEqual(addon.get_js_map_size(new Map()), 0);
+  });
+
+  it("can modify a JsMap", function () {
+    const map = new Map([[1, "a"]]);
+    addon.modify_js_map(map, 2, "b");
+    assert.deepEqual(
+      map,
+      new Map([
+        [1, "a"],
+        [2, "b"],
+      ])
+    );
+  });
+
+  it("returns undefined when accessing outside JsMap bounds", function () {
+    assert.strictEqual(addon.read_js_map(new Map(), "x"), undefined);
+  });
+
+  it("can clear a JsMap", function () {
+    const map = new Map([[1, "a"]]);
+    addon.clear_js_map(map);
+    assert.deepEqual(map, new Map());
+  });
+
+  it("can delete key from JsMap", function () {
+    const map = new Map([
+      [1, "a"],
+      ["z", 26],
+    ]);
+
+    assert.strictEqual(addon.delete_js_map(map, "unknown"), false);
+    assert.deepEqual(
+      map,
+      new Map([
+        [1, "a"],
+        ["z", 26],
+      ])
+    );
+
+    assert.strictEqual(addon.delete_js_map(map, 1), true);
+    assert.deepEqual(map, new Map([["z", 26]]));
+
+    assert.strictEqual(addon.delete_js_map(map, "z"), true);
+    assert.deepEqual(map, new Map());
+  });
+
+  it("can use `has` on JsMap", function () {
+    const map = new Map([
+      [1, "a"],
+      ["z", 26],
+    ]);
+
+    assert.strictEqual(addon.has_js_map(map, 1), true);
+    assert.strictEqual(addon.has_js_map(map, "z"), true);
+    assert.strictEqual(addon.has_js_map(map, "unknown"), false);
+  });
+
+  it("can use `forEach` on JsMap", function () {
+    const map = new Map([
+      [1, "a"],
+      ["z", 26],
+    ]);
+    const collected = [];
+
+    assert.strictEqual(
+      addon.for_each_js_map(map, (value, key, map) => {
+        collected.push([key, value, map]);
+      }),
+      undefined
+    );
+
+    assert.deepEqual(collected, [
+      [1, "a", map],
+      ["z", 26, map],
+    ]);
+  });
+
+  it("can use `groupBy` on JsMap", function () {
+    const inventory = [
+      { name: "asparagus", type: "vegetables", quantity: 9 },
+      { name: "bananas", type: "fruit", quantity: 5 },
+      { name: "goat", type: "meat", quantity: 23 },
+      { name: "cherries", type: "fruit", quantity: 12 },
+      { name: "fish", type: "meat", quantity: 22 },
+    ];
+
+    const restock = { restock: true };
+    const sufficient = { restock: false };
+    const result = addon.group_by_js_map(inventory, ({ quantity }) =>
+      quantity < 6 ? restock : sufficient
+    );
+    assert.deepEqual(
+      result,
+      new Map([
+        [restock, [{ name: "bananas", type: "fruit", quantity: 5 }]],
+        [
+          sufficient,
+          [
+            { name: "asparagus", type: "vegetables", quantity: 9 },
+            { name: "goat", type: "meat", quantity: 23 },
+            { name: "cherries", type: "fruit", quantity: 12 },
+            { name: "fish", type: "meat", quantity: 22 },
+          ],
+        ],
+      ])
+    );
+  });
+});

test/napi/lib/types.js

@@ -90,4 +90,15 @@ describe("type checks", function () {
     assert(!addon.strict_equals(o1, o2));
     assert(!addon.strict_equals(o1, 17));
   });
+
+  it("instance_of", function () {
+    assert(addon.instance_of(new Error(), Error));
+    assert(!addon.instance_of(new Error(), Map));
+    assert(addon.instance_of(new Map(), Map));
+
+    function Car() {}
+    function Bike() {}
+    assert(addon.instance_of(new Car(), Car));
+    assert(!addon.instance_of(new Car(), Bike));
+  });
 });