Added Tensor.get_size() method to Node.js API

src/bindings/js/node/include/tensor.hpp

@@ -51,6 +51,9 @@ class TensorWrap : public Napi::ObjectWrap<TensorWrap> {
     Napi::Value get_shape(const Napi::CallbackInfo& info);
     /** @return Napi::String containing ov::element type. */
     Napi::Value get_element_type(const Napi::CallbackInfo& info);
+   /**@return Napi::Number containing tensor size as total number of elements.*/
+    Napi::Value get_size(const Napi::CallbackInfo& info);
+
 
 private:
     ov::Tensor _tensor;

src/bindings/js/node/lib/addon.ts

@@ -63,6 +63,7 @@ interface Tensor {
   getElementType(): element;
   getShape(): number[];
   getData(): number[];
+  getSize(): number;
 }
 interface TensorConstructor {
   new(type: element | elementTypeString,

src/bindings/js/node/src/tensor.cpp

@@ -48,7 +48,8 @@ Napi::Function TensorWrap::get_class(Napi::Env env) {
                        {InstanceAccessor<&TensorWrap::get_data>("data"),
                         InstanceMethod("getData", &TensorWrap::get_data),
                         InstanceMethod("getShape", &TensorWrap::get_shape),
-                        InstanceMethod("getElementType", &TensorWrap::get_element_type)});
+                        InstanceMethod("getElementType", &TensorWrap::get_element_type),
+                        InstanceMethod("getSize", &TensorWrap::get_size)});
 }
 
 ov::Tensor TensorWrap::get_tensor() const {
@@ -138,3 +139,17 @@ Napi::Value TensorWrap::get_shape(const Napi::CallbackInfo& info) {
 Napi::Value TensorWrap::get_element_type(const Napi::CallbackInfo& info) {
     return cpp_to_js<ov::element::Type_t, Napi::String>(info, _tensor.get_element_type());
 }
+
+
+
+Napi::Value TensorWrap::get_size(const Napi::CallbackInfo& info) {
+    if (info.Length() > 0) {
+        reportError(info.Env(), "getSize() does not accept any arguments.");
+        return info.Env().Null();
+    }
+    size_t size = _tensor.get_size();
+
+    double jsSize = static_cast<double>(size);
+
+    return Napi::Number::New(info.Env(), jsSize);
+}

src/bindings/js/node/tests/tensor.test.js

@@ -136,3 +136,73 @@ describe('Tensor element type', () => {
     });
   });
 });
+
+
+describe('Tensor getSize', () => {
+
+  it('getSize returns the correct total number of elements', () => {
+    const tensor = new ov.Tensor(ov.element.f32, shape, data);
+    const expectedSize = shape.reduce((acc, dim) => acc * dim, 1);
+    assert.strictEqual(tensor.getSize(), expectedSize);
+  });
+
+  it('getSize should throw an error if arguments are provided', () => {
+    const tensor = new ov.Tensor(ov.element.f32, shape, data);
+    assert.throws(
+      () => tensor.getSize(1),
+      { message: 'getSize() does not accept any arguments.' }
+    );
+  });
+});
+
+
+describe('Tensor getSize for various shapes', () => {
+  it('calculates size correctly for a common image data shape [3, 224, 224]', () => {
+    const shape = [3, 224, 224];
+    const expectedSize = 3*224*224;
+    const tensorData = new Float32Array(expectedSize).fill(0);
+    const tensor = new ov.Tensor(ov.element.f32, shape, tensorData);
+    assert.strictEqual(tensor.getSize(), expectedSize);
+  });
+
+  it('calculates size correctly for a scalar wrapped in a tensor [1]', () => {
+    const shape = [1];
+    const expectedSize = 1;
+    const tensorData = new Float32Array(expectedSize).fill(0);
+    const tensor = new ov.Tensor(ov.element.f32, shape, tensorData);
+    assert.strictEqual(tensor.getSize(), expectedSize);
+  });
+
+  it('calculates size correctly for a vector [10]', () => {
+    const shape = [10];
+    const expectedSize = 10;
+    const tensorData = new Float32Array(expectedSize).fill(0);
+    const tensor = new ov.Tensor(ov.element.f32, shape, tensorData);
+    assert.strictEqual(tensor.getSize(), expectedSize);
+  });
+
+  it('calculates size correctly for a small 3D tensor [2, 5, 5]', () => {
+    const shape = [2, 5, 5];
+    const expectedSize = 2*5*5;
+    const tensorData = new Float32Array(expectedSize).fill(0);
+    const tensor = new ov.Tensor(ov.element.f32, shape, tensorData);
+    assert.strictEqual(tensor.getSize(), expectedSize);
+  });
+
+  it('calculates size correctly for a small square matrix [4, 4]', () => {
+    const shape = [4, 4];
+    const expectedSize = 16;
+    const tensorData = new Float32Array(expectedSize).fill(0);
+    const tensor = new ov.Tensor(ov.element.f32, shape, tensorData);
+    assert.strictEqual(tensor.getSize(), expectedSize);
+  });
+
+  it('calculates size correctly for another small 3D tensor [2, 3, 3]', () => {
+    const shape = [2, 3, 3];
+    const expectedSize = 18;
+    const tensorData = new Float32Array(expectedSize).fill(0);
+    const tensor = new ov.Tensor(ov.element.f32, shape, tensorData);
+    assert.strictEqual(tensor.getSize(), expectedSize);
+  });
+});
+