[Javascript] Fix syntax error for signed enum (#5503)

* wrap quotes to enum name map to prevent syntax errorn when enum value is negative

* Add a test that covers signed enum case

tests/monster_test_generated.rs

@@ -235,6 +235,72 @@ pub fn enum_name_color(e: Color) -> &'static str {
   ENUM_NAMES_COLOR[index as usize]
 }
 
+#[allow(non_camel_case_types)]
+#[repr(i8)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum Race {
+  None = -1,
+  Human = 0,
+  Dwarf = 1,
+  Elf = 2,
+
+}
+
+const ENUM_MIN_RACE: i8 = -1;
+const ENUM_MAX_RACE: i8 = 2;
+
+impl<'a> flatbuffers::Follow<'a> for Race {
+  type Inner = Self;
+  #[inline]
+  fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    flatbuffers::read_scalar_at::<Self>(buf, loc)
+  }
+}
+
+impl flatbuffers::EndianScalar for Race {
+  #[inline]
+  fn to_little_endian(self) -> Self {
+    let n = i8::to_le(self as i8);
+    let p = &n as *const i8 as *const Race;
+    unsafe { *p }
+  }
+  #[inline]
+  fn from_little_endian(self) -> Self {
+    let n = i8::from_le(self as i8);
+    let p = &n as *const i8 as *const Race;
+    unsafe { *p }
+  }
+}
+
+impl flatbuffers::Push for Race {
+    type Output = Race;
+    #[inline]
+    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
+        flatbuffers::emplace_scalar::<Race>(dst, *self);
+    }
+}
+
+#[allow(non_camel_case_types)]
+const ENUM_VALUES_RACE:[Race; 4] = [
+  Race::None,
+  Race::Human,
+  Race::Dwarf,
+  Race::Elf
+];
+
+#[allow(non_camel_case_types)]
+const ENUM_NAMES_RACE:[&'static str; 4] = [
+    "None",
+    "Human",
+    "Dwarf",
+    "Elf"
+];
+
+pub fn enum_name_race(e: Race) -> &'static str {
+  let index = e as i8 - Race::None as i8;
+  ENUM_NAMES_RACE[index as usize]
+}
+
 #[allow(non_camel_case_types)]
 #[repr(u8)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
@@ -991,6 +1057,7 @@ impl<'a> Monster<'a> {
       if let Some(x) = args.pos { builder.add_pos(x); }
       builder.add_hp(args.hp);
       builder.add_mana(args.mana);
+      builder.add_signed_enum(args.signed_enum);
       builder.add_any_ambiguous_type(args.any_ambiguous_type);
       builder.add_any_unique_type(args.any_unique_type);
       builder.add_testbool(args.testbool);
@@ -1046,6 +1113,7 @@ impl<'a> Monster<'a> {
     pub const VT_ANY_AMBIGUOUS_TYPE: flatbuffers::VOffsetT = 94;
     pub const VT_ANY_AMBIGUOUS: flatbuffers::VOffsetT = 96;
     pub const VT_VECTOR_OF_ENUMS: flatbuffers::VOffsetT = 98;
+    pub const VT_SIGNED_ENUM: flatbuffers::VOffsetT = 100;
 
   #[inline]
   pub fn pos(&self) -> Option<&'a Vec3> {
@@ -1257,6 +1325,10 @@ impl<'a> Monster<'a> {
     self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Color>>>(Monster::VT_VECTOR_OF_ENUMS, None)
   }
   #[inline]
+  pub fn signed_enum(&self) -> Race {
+    self._tab.get::<Race>(Monster::VT_SIGNED_ENUM, Some(Race::None)).unwrap()
+  }
+  #[inline]
   #[allow(non_snake_case)]
   pub fn test_as_monster(&self) -> Option<Monster<'a>> {
     if self.test_type() == Any::Monster {
@@ -1396,6 +1468,7 @@ pub struct MonsterArgs<'a> {
     pub any_ambiguous_type: AnyAmbiguousAliases,
     pub any_ambiguous: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
     pub vector_of_enums: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a , Color>>>,
+    pub signed_enum: Race,
 }
 impl<'a> Default for MonsterArgs<'a> {
     #[inline]
@@ -1448,6 +1521,7 @@ impl<'a> Default for MonsterArgs<'a> {
             any_ambiguous_type: AnyAmbiguousAliases::NONE,
             any_ambiguous: None,
             vector_of_enums: None,
+            signed_enum: Race::None,
         }
     }
 }
@@ -1645,6 +1719,10 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
     self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums);
   }
   #[inline]
+  pub fn add_signed_enum(&mut self, signed_enum: Race) {
+    self.fbb_.push_slot::<Race>(Monster::VT_SIGNED_ENUM, signed_enum, Race::None);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
     let start = _fbb.start_table();
     MonsterBuilder {