@param [ParamName] ...

@return ...

this is sample 
日本語ドキュメント


@note this is Note!
@see this is see!

Error Variable  param  is read-only within this context and cannot be set to a new value

function create<T>(ctor: { new(): T }) {
    return new ctor();
}
var c = create(MyClass); // c: MyClass

/** Generic class type. */
type Constructor<T> = { new (...args: any[]): T } | ((...args: any[]) => T) | Function;

module.exports = function main(){
    const UMG = require("UMG");
    const I = require('instantiator');
    const EMaker = require("editor-maker");

    //menu group settings
    if(!global.editorGroup){
        global.editorGroup = JavascriptWorkspaceItem.AddGroup(JavascriptWorkspaceItem.GetGroup("Root"), "Samples");
    }

    //Editor window with tab simple template
    EMaker.tabSpawner(
        {
            DisplayName:"Simple Tab Win",
            TabId: "SimpleTabWin@",
            Role: EJavascriptTabRole.MajorTab,
            Group: global.editorGroup
        },
        () => I(UMG.text({},"test"))
    )

    //deconstructor
    return () => {

    };
}

// bootstrap to initiate live-reloading dev env.
try {
    module.exports = () => {
        let cleanup = null

        // wait for map to be loaded.
        process.nextTick(() => cleanup = main());

        // live-reloadable function should return its cleanup function
        return () => cleanup()
    }
}
catch (e) {
    require('bootstrap')('extension-Button')
}

UMG.div({【オプションのObject】}, ...children)

UMG.span({【オプションのObject】}, ...children)

UMG.div(
  {
    //オプションでの設定
    Slot:{Size:{Value:10, SizeRule:ESlateSizeRule.Fill}},
    //入れ子が面倒な時は以下の方法でも設定可能
    "slot.size.size-rule":ESlateSizeRule.Fill,
    //...
  },
  //...
)

UMG.div(
    {},
    UMG.text({},"text"),
    UMG(TextBlock,{Text:"text"})
)

//エディタ組み込みのフォントにアクセスするために取得
const GEngine = Root.GetEngine();

//フォント：SmallFont、サイズ10が大体エディタ拡張の通常のフォントサイズ
UMG.text({Font:{FontObject:GEngine.SmallFont,Size:10}},"text");

UMG.span(
    {},
    UMG(UImage,
    {
        Brush:{
            ImageSize:{X:248,Y:138},
            ResourceObject:UObject.Load("/Game/Image")
        }
    })
)

UMG.img({Brush:{ResourceObject:UObject.Load("/Game/Image")}})

UMG(Button,{},"default button")

const GEngine = Root.GetEngine();
const btnFColor = new LinearColor()
    btnFColor.R = btnFColor.G = btnFColor.B = 0;
    btnFColor.A = 100;

//simple button with font decoration
UMG(Button,{ColorAndOpacity:btnFColor},UMG.text({Font:{FontObject:GEngine.SmallFont,Size:10}},"decorated text button"))

    class A/* Struct */{
        ctor(){
            this.desc = "A desc"
            this.name = "A"
        }
        properties(){
            this.desc /* String */
            this.name /* String */
        }
    }
    class B/* Struct */{
        ctor(){
            this.desc = "B desc"
            this.name = "B"
        }
        properties(){
            this.desc /* String */
            this.name /* String */
        }
    }

    let data = [
        new (UClass()(global, A)),
        new (UClass()(global, B)),
    ]

OnGenerateRowEvent: (item, column) => {
    let s = ""
    switch(column){
        case "Name":
            s = item ? item.name : column;
            break;
        case "Desc":
            s = item ? item.desc : column;
            break;
        default:
            s = "default"
    }

    let design = 
        UMG(JavascriptTextBlock,
            {
                Font : {
                    FontObject : GEngine.SmallFont,
                    Size : 10
                },
                Text : s
            }
        )
    return I(design)
},

//PropertyEditor showing props
class ShowProps{
    ctor(){
        //default value set 

        this.myInt = 123;
        this.myFloat = 987.6;
    }
    properties(){
        this.myBoolean /* EditAnywhere+bool */;
        this.myInt /* EditAnywhere+Int */;
        this.myFloat /* EditAnywhere+float */;
        this.myIntArray /* EditAnywhere+Int[] */;
        this.myString /* EditAnywhere+String */;
        this.myVector2d /* EditAnywhere+Vector2D */;
        this.myVector /* EditAnywhere+Vector */;
        this.myActor /* EditAnywhere+Actor */;
        this.myColor /* EditAnywhere+Color */;
        this.someProp /* EditAnywhere+Category:MyCategory+DisplayName:My Prop Name+int */;
        this.advancedProp /* EditAnywhere+Category:MyCategory+AdvancedDisplay+Color */
    }
}

let UShowProps = UClass()(global, ShowProps)
let ushowProp = new UShowProps();

UMG(PropertyEditor,
{
    OnChange:(propertyName) => {
        //...
    },
    $link:(elem)=>{
        elem.SetObject(ushowProp)
        elem.updateData = _ => {
            elem.SetObject(ushowProp)
        }
    },
    $unlink:(elem) =>{
        //...
    }
})

const EMaker = require("editor-maker")
let tab = EMaker.tab(
            {
                TabId:"Tab",
                Role:EJavascriptTabRole.NamadTab,
                DisplayName:"Tab"
            },
            ()=>{
                return I(UMG.text({},"text"))
            }
);

    let tabManager = new JavascriptEditorTabManager(JavascriptLibrary.CreatePackage(null,'/Script/Javascript'))
    tabManager.Tabs = [tab, /* ... */]
    tabManager.Layout = JSON.stringify(tabLayout)

    //...

    $link:elem => {
         elem.AddChild(tabManager).Size.SizeRule  = "Fill"
   }

UMG(【UI】,【UIのオプション】);

UMG(Button,
  {
     $link:elem => {},
     $unlink:elem => {}
  }
)

UMG<T extends Visual>(
  T,
  {
    $link?:(elem:T)=>void,
    $unlink?:(elem:T)=>void
  },
//...

declare class Button extends ContentWidget { 
        //略
    OnClicked: UnrealEngineMulticastDelegate<() => void>;
    OnPressed: UnrealEngineMulticastDelegate<() => void>;
    OnReleased: UnrealEngineMulticastDelegate<() => void>;
    OnHovered: UnrealEngineMulticastDelegate<() => void>;
    OnUnhovered: UnrealEngineMulticastDelegate<() => void>;
//以後省略

UMG(Button,
  {
     OnClicked: _ => {
        //do something
     }
  }
)

//エディタ（World Outlinerなど）上で選択したActorインスタンスの配列を取得
let usel = JavascriptEditorEngineLibrary.GetSelectedSet(Root.GetEngine(), Actor)
let sel = usel.GetSelectedObjects()

//一つ目のActorインスタンスを取得
let p = sel.Out[0];

UMG(【UI】,【UIのオプション】,【子要素UI】);

Context.WriteDTS(Context.Paths[0] + 'typings/ue.d.ts', true);

WriteDTS(Target: string,bIncludingTooltip: boolean): boolean;

console.log("hi console log!")

HelloFromBP.HelloBP();

UCLASS([specifier, specifier, ...], [meta(key=value, key=value, ...)])
class ClassName : public ParentName
{
    GENERATED_BODY()
}

class ClassName /* ClassFlag+ClassFlag+... */ extends ParentClass {
   ctor() {
     // initialization
     // component setup
   }
   properties() {
     // property-declarations
   }
}

//transformed into corresponding USTRUCT and UCLASS
let cls = require('uclass')()(global, ClassName);

UFUNCTION([specifier, specifier, ...], [meta(key=value, key=value, ...)])
ReturnType FunctionName([Parameter, Parameter, ...])

class ClassName{
  //...
  FunctionName([
    Parameter /* PropertyFlag+ParamType */,
    Parameter /* PropertyFlag+ParamType */,
     ... 
  ]) /* specifier+ReturnType */
}

UPROPERTY([specifier, specifier, ...], [meta(key=value, key=value, ...)])
Type VariableName;

class MyClassName{
  //...
  properties(){
    this.VariableName /* specifier+specifier+...+Type */;
  }
}

properties() {
  //bEditConditionが有効ならエディタ上で編集可能に
  this.EditConditionVariable /* EditAnywhere+Category:condition+EditCondition:bEditCondition+int32*/
  //エディタ上で普段は隠しておく
  this.bEditCondition /* EditAnywhere+Category:condition+AdvancedDisplay+bool */;  
}

USTRUCT([Specifier, Specifier, ...])
struct StructName
{
    GENERATED_USTRUCT_BODY()
};

class StructName /* Struct+Specifier+Specifier+... */{
   properties() {
     //property-declarations
   }
}