Implement #[ts(optional = nullable)]

[NyxCode]

This PR implements #[ts(optional = nullable)], as discussed in #112.
#[ts(optional)] Option<T> still generates t?: T, while #[ts(optional = nullable)] generates t?: T | null.

I plan on following this up at some point with support for the serde attributes outlined in #112.

[NyxCode]

Closes #112

[NyxCode]

@escritorio-gustavo would love to hear what you think about this!

[escritorio-gustavo]

This is awesome! I thought there would be a separate #[ts(nullable)] attribute, but making it an argument for #[ts(optional)] is way better to prevent it from being used instead of an actual Option

[escritorio-gustavo]

Quick question, is the optional field needed? It always true unless the attribute is not present. This could an Option with just one field for nullable

#[derive(default)]
pub struct Nullable(pub bool);

#[derive(Default)]
pub struct FieldAttr {
    pub type_override: Option<String>,
    pub type_override: Option<String>,
    pub rename: Option<String>,
    pub rename: Option<String>,
    pub inline: bool,
    pub inline: bool,
    pub skip: bool,
    pub skip: bool,
    pub optional: bool,
    pub optional: Option<Nullable>,
    pub flatten: bool,
    pub flatten: bool,
}

let (ty, optional_annotation) = match optional {
      Some(Nullable(nullable) => {
          let inner_type = extract_option_argument(&field.ty)?; // inner type of the optional
          match nullable {
              true => (&field.ty, "?"),  // if it's nullable, we keep the original type
              false => (inner_type, "?"), // if not, we use the Option's inner type
          }
      },
      None => (&field.ty, "")
 };

This is just an idea though, I'm totally fine with merging this as is

[NyxCode]

Quick question, is the optional field needed? It always true unless the attribute is not present. This could an Option with just one field for nullable

#[derive(default)]
pub struct Nullable(pub bool);

#[derive(Default)]
pub struct FieldAttr {
    pub type_override: Option<String>,
    pub type_override: Option<String>,
    pub rename: Option<String>,
    pub rename: Option<String>,
    pub inline: bool,
    pub inline: bool,
    pub skip: bool,
    pub skip: bool,
    pub optional: bool,
    pub optional: Option<Nullable>,
    pub flatten: bool,
    pub flatten: bool,
}

let (ty, optional_annotation) = match optional {
      Some(Nullable(nullable) => {
          let inner_type = extract_option_argument(&field.ty)?; // inner type of the optional
          match nullable {
              true => (&field.ty, "?"),  // if it's nullable, we keep the original type
              false => (inner_type, "?"), // if not, we use the Option's inner type
          }
      },
      None => (&field.ty, "")
 };

This is just an idea though, I'm totally fine with merging this as is

Sure, that'd work as well. I tried a couple of options, and the one i ended up with felt the least ugly to me.
If you've got strong opinions on this though, feel free to change it.

[escritorio-gustavo]

Sure, that'd work as well. I tried a couple of options, and the one i ended up with felt the least ugly to me.
If you've got strong opinions on this though, feel free to change it.

I don't think there's a need for that, I was just curious