SushiScriptCore 1.0.3

Sushi

Library for converting .NET classes to script classes.

Author: Jeroen Vorsselman @ 2023

GitHub

NuGet

Main features

• Generates ECMAScript 5, ECMAScript 6 and TypeScript classes using .NET types.
• Support for nested generic types.
• Support for .NET Core.
• Vastly improved compared to its predecessor.
• Creates extended classes and their constructors.
• Simple object mapping:
  • ES5 classes use (optional) _.extend from UnderscoreJS.
  • ES6 and TypeScript use Object.assign().
• Allows custom datatype conversion.
• Improved type dependency tree ordering.
• Adds documentation from the XML file generated on project build.
• 85% Code coverage.
• Assigns explicitly specified default values for "simple" types. <br>

How to use

1. Specify what types to use in an assembly by adding:
   1. An ConvertToScriptAttribute to the class, or;
   2. Inheriting from the IScriptModel interface.
   3. You can also exclude models using the IgnoreForScriptAttribute.
2. Create an instance of the SushiConverter:
   1. SushiConverter(ICollection<Type> types) Create an instance using the given collection of types.
   2. SushiConverter(ICollection<Type> types, string assemblyDocPath) Delegates to #1 and adds a path to the XML documentation file.
   3. SushiConverter(params Type[] types) Delegates to #1.
   4. SushiConverter(Assembly assembly, string assemblyDocPath) Delegates to #1 using the assembly.ExportedTypes and adds a path to the XML documentation file.
   5. REMARK: All given types MUST inherit from the Interface or Attribute or they will be ignored.
3. Create a ModelConverter for a specific language.

Example

var converter = new SushiConverter(assembly, xmlFilePath);
var indent = "\t";
var script = converter.TypeScript()
    .Convert(indent)
    .ConvertEnums()
    .ToString();

The following .NET class is used:

/// <summary>
///     Simple model to verify complex types.
/// </summary>
public sealed class TypeModel : ViewModel
{
	/// <summary>
	///     A nullable boolean.
	/// </summary>
	public bool? NullableBool { get; set; } = null;
	
	/// <summary>
	///     A nullable string, defaults to null.
	/// </summary>
	public string? NullableString { get; set; } = null;

	/// <summary>
	///     A readonly string.
	/// </summary>
	public readonly string ReadonlyString = "readonly";

	/// <inheritdoc cref="Guid" />
	public new Guid Guid { get; set; } = Guid.NewGuid();

	public StudentViewModel Student { get; set; } = new StudentViewModel();
	public List<StudentViewModel> Students { get; set; }
	public List<List<StudentViewModel>> StudentPerClass { get; set; }
}

To generate this TypeScript model:

/**
 * Simple model to verify complex types.
 * @typedef {Object} TypeModel
 * @extends ViewModel 
 */
export class TypeModel extends ViewModel {
    /** A nullable boolean. */
    NullableBool: boolean | null = null;
    /** A nullable string, defaults to null. */
    NullableString!: string;
    Student: StudentViewModel | null = null;
    Students: Array<StudentViewModel | null> = [];
    StudentPerClass: Array<Array<StudentViewModel | null>> = [];
    /** A readonly string. */
    ReadonlyString!: string;

    public constructor(value?: any) {
        super(value);

        if (!(value instanceof Object))
            return;

        this.NullableBool = value.NullableBool;
        this.NullableString = value.NullableString;
        this.Student = value.Student;
        this.Students = value.Students;
        this.StudentPerClass = value.StudentPerClass;
        this.ReadonlyString = value.ReadonlyString;
    }

    static mapFrom(obj: any): TypeModel {
        return Object.assign(new TypeModel(), obj);
    }
}