chore: update docs how to use new annotations

Author: nmerget

docs/documentation/godot-js-scripts/code-in-editor.md

@@ -4,21 +4,24 @@
 > **NOTE:** Read [Godot Docs](https://docs.godotengine.org/en/stable/tutorials/plugins/running_code_in_the_editor.html#what-is-tool) for more details about `@tool`.
 
 
-If a GodotJS class is annotated with `@Tool()`, it'll be instantiated in the editor. 
+If a GodotJS class is annotated with `@bind.tool()`, it'll be instantiated in the editor. 
 Call `Engine.is_editor_hint()` in the script to check if it's running in the editor.  
 It's also possible to show warnings on a `Node` on `Scene` panel with `_get_configuration_warnings` defined. Here is a simple example:
 
 ```ts
 import { Engine, PackedStringArray, Sprite2D, Variant } from "godot";
-import { Export, Tool } from "godot.annotations";
+import { createClassBinder } from "godot.annotations";
 
-@Tool()
+const bind = createClassBinder();
+
+@bind()
+@bind.tool()
 export default class MyEditorSprite extends Sprite2D {
 
     /**
      * get/set property for `export` (both must be defined)
      */
-    @Export(Variant.Type.TYPE_FLOAT)
+    @bind.export(Variant.Type.TYPE_FLOAT)
     get speed(): number { return this._speed; }
     set speed(value: number) {
         if (this._speed != value) {
@@ -30,8 +33,8 @@ export default class MyEditorSprite extends Sprite2D {
     /**
      * plain field for `export`
      */
-    @Export(Variant.Type.TYPE_INT)
-    unused_int = 0;
+    @bind.export(Variant.Type.TYPE_INT)
+    accessor unused_int = 0;
 
     private _clockwise = false;
     private _speed = 0;
@@ -82,9 +85,12 @@ This is available in Godot by extending `EditorScript` in a script. This provide
 
 ```ts 
 import { EditorScript } from "godot";
-import { Tool } from "godot.annotations";
+import { createClassBinder } from "godot.annotations";
+
+const bind = createClassBinder();
 
-@Tool()
+@bind()
+@bind.tool()
 export default class MyEditorScript1 extends EditorScript {
     _run() {
         console.log("my editor script run");

docs/documentation/godot-js-scripts/decorators.md

@@ -2,31 +2,45 @@
 
 There are several decorators to help you define properties, signals, and other metadata for Godot objects.
 
+All decorators are accessed through the `createClassBinder` function:
+
+```ts
+import { createClassBinder } from "godot.annotations";
+
+const bind = createClassBinder();
+```
+
 ## Signal annotation
 
-You can define signals in your script using the `@ExportSignal` annotation:
+You can define signals in your script using the `@bind.signal()` decorator:
 
 ```ts
 import { Node, Signal } from "godot";
-import { ExportSignal } from "godot.annotations";
+import { createClassBinder } from "godot.annotations";
 
+const bind = createClassBinder();
+
+@bind()
 export default class MyJSNode extends Node {
-  @ExportSignal()
-  test!: Signal<(param1: string) => void>;
+  @bind.signal()
+  accessor test!: Signal<(param1: string) => void>;
 }
 ```
 
 For more information about signals, check this [link](signals.md).
 
 ## Tool annotation
 
-If a GodotJS class is annotated with `tool()`, it'll be instantiated in the editor.
+If a GodotJS class is annotated with `@bind.tool()`, it'll be instantiated in the editor.
 
 ```ts
 import { Node } from "godot";
-import { Tool } from "godot.annotations";
+import { createClassBinder } from "godot.annotations";
+
+const bind = createClassBinder();
 
-@Tool()
+@bind()
+@bind.tool()
 export default class MyTool extends Node {
   _ready() {
     // This code will run in the editor
@@ -39,13 +53,16 @@ For more information about running code in editor, check this [link](code-in-edi
 
 ## Icon annotation
 
-An icon can be used as node icon in the editor scene hierarchy with the annotation `@icon`.
+An icon can be used as node icon in the editor scene hierarchy with the annotation `@bind.icon()`.
 
 ```ts
 import { Sprite2D } from "godot";
-import { Icon } from "godot.annotations";
+import { createClassBinder } from "godot.annotations";
 
-@Icon("res://icon/affiliate.svg")
+const bind = createClassBinder();
+
+@bind()
+@bind.icon("res://icon/affiliate.svg")
 export default class MySprite extends Sprite2D {}
 ```
 
@@ -57,16 +74,18 @@ In `GodotJS`, class member properties/variables can be exported.
 This means their value gets saved along with the resource
 (such as the scene) they're attached to.
 They will also be available for editing in the property editor.
-Exporting is done by using the `@Export` annotation.
+Exporting is done by using the `@bind.export()` decorator.
 
 ```ts
-import { Export } from "godot.annotations";
+import { Variant } from "godot";
+import { createClassBinder } from "godot.annotations";
+
+const bind = createClassBinder();
 
+@bind()
 export default class Shooter extends Sprite2D {
-  // type must be explicitly provided as the first parameter of @Export
-  // cuz static type is actually a phantom in typescript
-  @Export(Variant.Type.TYPE_FLOAT)
-  speed: number = 0;
+  @bind.export(Variant.Type.TYPE_FLOAT)
+  accessor speed: number = 0;
 
   // ...
 }
@@ -84,18 +103,18 @@ The retrieval of default value is implemented through `Class Default Object (CDO
 ### Basic Use
 
 ```ts
-@Export(Variant.Type.TYPE_STRING)
-address: string = "somewhere"; // `:string` can be omitted here
+@bind.export(Variant.Type.TYPE_STRING)
+accessor address: string = "somewhere";
 
-@Export(Variant.Type.TYPE_INT)
-age: number = 0; // `:number` can be omitted here
+@bind.export(Variant.Type.TYPE_INT)
+accessor age: number = 0;
 ```
 
-If there's no default value, `default value` of the give type will be used (`0` in this case).
+If there's no default value, `default value` of the given type will be used (`0` in this case).
 
 ```ts
-@Export(Variant.Type.TYPE_INT)
-age: number;
+@bind.export(Variant.Type.TYPE_INT)
+accessor age: number;
 ```
 
 ### Exported Enum Properties
@@ -105,8 +124,8 @@ Enum value properties can be exported with the built-in support in the property
 > **NOTE:** So far, only `int` is supported as enum value.
 
 ```ts
-@ExportEnum(MyColor)
-color: MyColor = MyColor.White;
+@bind.exportEnum(MyColor)
+accessor color: MyColor = MyColor.White;
 ```
 
 The value can be easily chosen from a dropdown list in the editor.

docs/documentation/godot-js-scripts/intro.md

@@ -70,4 +70,4 @@ Check out [decorators](decorators.md) for more information.
 ## Auto-Completion and Codegen
 
 By default, GodotJS wil auto generate some TypeScript files based on you project.
-Check out [auto-completion](auto-completion.md) for more information.
+Check out [auto-completion](auto-completion-and-codegen.md) for more information.

docs/documentation/godot-js-scripts/signals.md

@@ -4,17 +4,20 @@ You can define signals based on the amount of arguments you want to pass:
 
 ```ts
 import { Node, Signal } from "godot";
-import { ExportSignal } from "godot.annotations";
+import { createClassBinder } from "godot.annotations";
 
+const bind = createClassBinder();
+
+@bind()
 export default class MyNode extends Node {
-  @ExportSignal()
-  declare no_arg!: Signal<() => void>;
+  @bind.signal()
+  accessor no_arg!: Signal<() => void>;
 
-  @ExportSignal()
-  declare one_arg!: Signal<(param1: string) => void>;
+  @bind.signal()
+  accessor one_arg!: Signal<(param1: string) => void>;
 
-  @ExportSignal()
-  declare two_args!: Signal<(param1: number, param2: string) => void>;
+  @bind.signal()
+  accessor two_args!: Signal<(param1: number, param2: string) => void>;
 }
 ```
 
@@ -75,12 +78,15 @@ export default class MyClass extends Node {
 A `Signal` can be awaitable in javascript by calling `as_promise()`:
 
 ```ts
-import { Node, Signal1 } from "godot";
-import { signal } from "godot.annotations";
+import { Node, Signal } from "godot";
+import { createClassBinder } from "godot.annotations";
+
+const bind = createClassBinder();
 
+@bind()
 class ExampleClass extends Node {
-  @signal()
-  declare test_signal!: Signal1<number>;
+  @bind.signal()
+  accessor test_signal!: Signal<(value: number) => void>;
 
   _ready() {
     test();

docs/examples/reuse-custom-resources.md

@@ -7,12 +7,15 @@ This example shows how to create a custom resource and reuse it with different s
 We create a new file `character-attributes.ts` and add this code to it:
 
 ```ts title="character-attributes.ts"
-import { Export } from "godot.annotations";
+import { createClassBinder } from "godot.annotations";
 import { Resource, Variant } from "godot";
 
+const bind = createClassBinder();
+
+@bind()
 export default class CharacterAttributes extends Resource {
-  @Export(Variant.Type.TYPE_INT)
-  health: number = 5;
+  @bind.export(Variant.Type.TYPE_INT)
+  accessor health: number = 5;
 }
 ```
 
@@ -33,15 +36,18 @@ Create a new file `index.ts` and add this code to it:
 
 ```ts title="index.ts"
 import { Node, Variant } from "godot";
-import { Export } from "godot.annotations";
+import { createClassBinder } from "godot.annotations";
 import CharacterAttributes from "./character-attributes";
 
+const bind = createClassBinder();
+
+@bind()
 export default class ResourceExample extends Node {
-  @Export(Variant.Type.TYPE_OBJECT)
-  warriorAttributes: CharacterAttributes | undefined = undefined;
+  @bind.export(Variant.Type.TYPE_OBJECT)
+  accessor warriorAttributes: CharacterAttributes | undefined = undefined;
 
-  @Export(Variant.Type.TYPE_OBJECT)
-  mageAttributes: CharacterAttributes | undefined = undefined;
+  @bind.export(Variant.Type.TYPE_OBJECT)
+  accessor mageAttributes: CharacterAttributes | undefined = undefined;
 
   _ready(): void {
     console.log("warrior health", this.warriorAttributes?.health);