update to docusaurus 3.8.1 & add scene reload docs

Author: joaoborks

README.md

@@ -18,7 +18,7 @@ You can download the latest version of Node.js from [here](https://nodejs.org/en
   ```
 3. To run the site locally:
   ```bash
-  npx docusaurus start
+  npx run start
   ```
   This will start a local development server at `http://localhost:3000`.
 4. To run the site locally in a different locale (e.g., Português Brasileiro):
@@ -27,6 +27,38 @@ You can download the latest version of Node.js from [here](https://nodejs.org/en
   ```
   This will start the site with the specified locale.
 
+## Versioning
+
+To start documentation on a new version, run:
+
+```bash
+npm run docusaurus docs:version <version>
+```
+
+This will copy the latest documentation and place it into the `version-<version>` folder.
+You can update the files inside `docs/` to reflect the new documentation version.
+
+Make sure to update the current version name as well in the `docusaurus.config.js` file at:
+
+```js
+const config = {
+  presets: [
+    [
+      ({
+        docs: {
+          lastVersion: 'current',
+          versions: {
+            current: {
+              label: '<version>'
+            }
+          }
+        }
+      })
+    ]
+  ]
+}
+```
+
 ## Building the Website Locally
 
 If you want to validate the site build before pushing, run the following command:

docs/advanced-usage/core-concepts.md

@@ -56,6 +56,7 @@ flowchart TB
 
 :::info
 **Scene Operations** refer to the Load, Unload and Transition operations.
+A Reload operation is considered a Transition operation.
 :::
 
 We will cover each of these structures in the next pages.

docs/advanced-usage/core-scene-manager.md

@@ -25,6 +25,8 @@ public interface ISceneManager : IDisposable
 
     Task<SceneResult> TransitionAsync(SceneParameters sceneParameters, ILoadSceneInfo intermediateSceneReference = default, CancellationToken token = default);
 
+    Task<SceneResult> ReloadActiveSceneAsync(ILoadSceneInfo intermediateSceneReference = null, CancellationToken token = default);
+
     Task<SceneResult> LoadAsync(SceneParameters sceneParameters, IProgress<float> progress = null, CancellationToken token = default);
 
     Task<SceneResult> UnloadAsync(SceneParameters sceneParameters, CancellationToken token = default);
@@ -49,7 +51,7 @@ The `CoreSceneManager` is expected to be used as a layer on top of the Unity `Sc
 flowchart LR
     usm(Unity Scene Manager)
     scd(Core Scene Manager)
-    
+
     scd ==> usm
 
     scd --> s_a(["Scene [0]"]) <--> usm
@@ -58,7 +60,7 @@ flowchart LR
 
 ```
 
-The `ISceneManager` interface defines that the `LoadAsync`, `UnloadAsync` and `TransitionAsync` methods return a `Task<SceneResult>`.
+The `ISceneManager` interface defines that the `LoadAsync`, `UnloadAsync`, `TransitionAsync` and `ReloadActiveSceneAsync` methods return a `Task<SceneResult>`.
 This means you can _await_ those methods if they are implemented with the _async_ keyword, or you can subscribe to the `SceneLoaded` or `SceneUnloaded` events to receive the same scenes you would via the _async_ methods.
 
 :::info

docs/getting-started/basic-usage.md

@@ -5,7 +5,7 @@ description: Basic introduction to the usage of My Scene Manager.
 
 # Basic Usage
 
-Loading scenes with this package implies that the scenes **will always be loaded as Additive**. That is simply because there is no advantage in loading scenes in the **Single** load scene mode when you expect to work with multiple scenes. 
+Loading scenes with this package implies that the scenes **will always be loaded as Additive**. That is simply because there is no advantage in loading scenes in the **Single** load scene mode when you expect to work with multiple scenes.
 
 You will be using the `MySceneManager` static class to perform the scene operations.
 
@@ -103,6 +103,21 @@ The reference type must be the same for the target scene and the intermediate sc
 
 Check the [Loading Scene Examples](../samples/loading-scene-examples.md) Sample to try different loading scenes when performing **Scene Transitions**.
 
+## Scene Reloading
+
+You can reload the active scene using the `ReloadActiveSceneAsync` method.
+A scene reload is also a **scene transition** internally.
+It will load the active scene via the same reference it was loaded initially.
+
+Just like with **Scene Transitions**, you can also pass an intermediate loading scene.
+
+```cs
+MySceneManager.ReloadActiveSceneAsync("my-loading-scene");
+
+// No loading screen:
+MySceneManager.ReloadActiveSceneAsync(intermediateSceneReference: null);
+```
+
 ## Async Programming
 
 All scene operations are awaitable and can be used in coroutines as well. For example:

docs/upgrades/from-3-to-4.md

@@ -20,6 +20,7 @@ It completely removes the `ISceneLoader` implementations and adds a static `MySc
 * Merged single and multiple scene methods via the new `SceneParameter` struct.
 * Merged all return types to `Task<SceneResult>`, which can return a single or multiple scenes, be awaited and be used in coroutines with `WaitTask`. ([#49](https://github.com/mygamedevtools/scene-loader/issues/49))
 * Removed all [UniTask] references, but it's still compatible.
+* Added the `ReloadActiveSceneAsync` method to simplify reloading scenes. ([#51](https://github.com/mygamedevtools/scene-loader/issues/51))
 * Improved scene match when unloading scenes. ([#44](https://github.com/mygamedevtools/scene-loader/issues/44))([#48](https://github.com/mygamedevtools/scene-loader/issues/48))
 * Added the [Loading Scene Examples](../samples/loading-scene-examples.md) Sample. ([#36](https://github.com/mygamedevtools/scene-loader/issues/36))
 * Published to the [Unity Asset Store](https://assetstore.unity.com/packages/slug/313159). ([#38](https://github.com/mygamedevtools/scene-loader/issues/38))

docusaurus.config.js

@@ -42,6 +42,11 @@ const config = {
     mermaid: true
   },
 
+  future: {
+    v4: true,
+    experimental_faster: true,
+  },
+
   presets: [
     [
       'classic',
@@ -52,10 +57,9 @@ const config = {
           editUrl:
             'https://github.com/mygamedevtools/scene-loader/tree/docs/',
           lastVersion: 'current',
-          versions:
-          {
+          versions: {
             current: {
-              label: '4.0.0'
+              label: '4.1.0'
             },
           }
         },

i18n/pt-BR/code.json

@@ -382,6 +382,9 @@
   "homepage.featureComparison.sceneTransition": {
     "message": "Transição de Cena Async"
   },
+  "homepage.featureComparison.sceneReloading": {
+    "message": "Recarregamento de Cena Async"
+  },
   "homepage.featureComparison.asyncAwait": {
     "message": "Suporte a Async/Await"
   },

i18n/pt-BR/docusaurus-plugin-content-docs/current/advanced-usage/core-concepts.md

@@ -57,6 +57,7 @@ flowchart TB
 
 :::info
 **Operações de Cena** refere às operações de Carregar, Descarregar e Transicionar.
+Uma operação de Recarregar é considerada uma operação de Transicionar.
 :::
 
 Vamos cobrir cada uma dessas estruturas nas próximas páginas.

i18n/pt-BR/docusaurus-plugin-content-docs/current/advanced-usage/core-scene-manager.md

@@ -25,6 +25,8 @@ public interface ISceneManager : IDisposable
 
     Task<SceneResult> TransitionAsync(SceneParameters sceneParameters, ILoadSceneInfo intermediateSceneReference = default, CancellationToken token = default);
 
+    Task<SceneResult> ReloadActiveSceneAsync(ILoadSceneInfo intermediateSceneReference = null, CancellationToken token = default);
+
     Task<SceneResult> LoadAsync(SceneParameters sceneParameters, IProgress<float> progress = null, CancellationToken token = default);
 
     Task<SceneResult> UnloadAsync(SceneParameters sceneParameters, CancellationToken token = default);
@@ -49,7 +51,7 @@ O `CoreSceneManager` é projetado para ser usado como uma camada acima do `Scene
 flowchart LR
     usm(Unity Scene Manager)
     scd(Core Scene Manager)
-    
+
     scd ==> usm
 
     scd --> s_a(["Scene [0]"]) <--> usm
@@ -58,7 +60,7 @@ flowchart LR
 
 ```
 
-A interface `ISceneManager` define que os métodos `LoadAsync`, `UnloadAsync` e `TransitionAsync` retornam um `Task<SceneResult>`.
+A interface `ISceneManager` define que os métodos `LoadAsync`, `UnloadAsync`, `TransitionAsync` e `ReloadActiveSceneAsync` retornam um `Task<SceneResult>`.
 Isso significa que você pode usar _await_ nesses métodos se eles forem implementados como _async_, ou pode se inscrever nos eventos `SceneLoaded` ou `SceneUnloaded` para receber as mesmas cenas que receberia via métodos async.
 
 :::info

i18n/pt-BR/docusaurus-plugin-content-docs/current/getting-started/basic-usage.md

@@ -104,6 +104,21 @@ O tipo de referência precisa ser o mesmo para a cena alvo e para a cena interme
 
 Confira o Exemplo '[Loading Scene Examples](../samples/loading-scene-examples.md)' para testar diferentes tipos de cenas de carregamento durante **Transições de Cena**.
 
+## Recerregando Cenas
+
+Você pode recarregar a cena ativa usando o método `ReloadActiveSceneAsync`.
+Um recarregamento de cena também é uma **transição de cena** internamente.
+Isso irá recarregar a cena ativa pela mesma referência que a carregou inicialmente.
+
+Assim como nas **Transições de Cena**, você também pode providenciar uma cena intermediária de carregamento.
+
+```cs
+MySceneManager.ReloadActiveSceneAsync("my-loading-scene");
+
+// Sem cena de carregamento:
+MySceneManager.ReloadActiveSceneAsync(intermediateSceneReference: null);
+```
+
 ## Programação Async
 
 Todas as operações de cena são _awaitable_ e podem ser usadas em coroutines também. Por exemplo: