update namespaces to Native\Desktop

Author: gwleuverink

resources/views/docs/desktop/2/digging-deeper/broadcasting.md

@@ -46,9 +46,12 @@ NativePHP injects a `window.Native` object into every window. The `on()` method
 the second parameter that will run when the event specified in the first parameter is fired:
 
 ```js
-Native.on("Native\\Laravel\\Events\\Windows\\WindowBlurred", (payload, event) => {
-    //
-});
+Native.on(
+    'Native\\Desktop\\Events\\Windows\\WindowBlurred',
+    (payload, event) => {
+        //
+    },
+)
 ```
 
 ## Listening with Livewire
@@ -64,13 +67,13 @@ class AppSettings extends Component
 {
     public $windowFocused = true;
 
-    #[On('native:\\Native\\Laravel\\Events\\Windows\\WindowFocused')]
+    #[On('native:\\Native\\Desktop\\Events\\Windows\\WindowFocused')]
     public function windowFocused()
     {
         $this->windowFocused = true;
     }
 
-    #[On('native:\\Native\\Laravel\\Events\\Windows\\WindowBlurred')]
+    #[On('native:\\Native\\Desktop\\Events\\Windows\\WindowBlurred')]
     public function windowBlurred()
     {
         $this->windowFocused = false;
@@ -81,8 +84,8 @@ class AppSettings extends Component
 You may find it more convenient to use PHP's class name resolution keyword, `::class`:
 
 ```php
-use Native\Laravel\Events\Windows\WindowBlurred;
-use Native\Laravel\Events\Windows\WindowFocused;
+use Native\Desktop\Events\Windows\WindowBlurred;
+use Native\Desktop\Events\Windows\WindowFocused;
 
 class AppSettings extends Component
 {

resources/views/docs/desktop/2/digging-deeper/child-processes.md

@@ -62,15 +62,15 @@ only be able to run while your application is running.**
 
 PHP has good built-in support for running arbitrary programs in separate processes. For example:
 
--   [`shell_exec`](https://www.php.net/manual/en/function.shell-exec.php) allows you to run commands and return their
-    output to your application.
--   [`proc_open`](https://www.php.net/manual/en/function.proc-open.php) allows you to spin up a command with more control
-    over how its input and output streams are handled.
+- [`shell_exec`](https://www.php.net/manual/en/function.shell-exec.php) allows you to run commands and return their
+  output to your application.
+- [`proc_open`](https://www.php.net/manual/en/function.proc-open.php) allows you to spin up a command with more control
+  over how its input and output streams are handled.
 
 While these can be used in your NativePHP application, consider that they:
 
--   May block the script that is executing them until the sub-process has finished.
--   May become orphaned from your application, allowing them to continue running after your app has quit.
+- May block the script that is executing them until the sub-process has finished.
+- May become orphaned from your application, allowing them to continue running after your app has quit.
 
 Runaway orphaned processes could negatively impact your user's system and can become tricky to manage without user
 intervention. You should be cautious about starting processes this way.
@@ -85,15 +85,15 @@ throughout your application.
 You may start a process using the `ChildProcess` facade:
 
 ```php
-use Native\Laravel\Facades\ChildProcess;
+use Native\Desktop\Facades\ChildProcess;
 
 ChildProcess::start(
     cmd: 'tail -f storage/logs/laravel.log',
     alias: 'tail'
 );
 ```
 
-The `start` method will return a `Native\Laravel\ChildProcess` instance, which represents the process. You may interact
+The `start` method will return a `Native\Desktop\ChildProcess` instance, which represents the process. You may interact
 directly with this instance to make changes to that process, but this does not necessarily mean that the
 process was started.
 
@@ -157,7 +157,7 @@ You can use the `ChildProcess` facade's `get` method to get a running process wi
 $tail = ChildProcess::get('tail');
 ```
 
-This will return a `Native\Laravel\ChildProcess` instance.
+This will return a `Native\Desktop\ChildProcess` instance.
 
 ### Getting all processes
 
@@ -167,14 +167,14 @@ You can use the `ChildProcess` facade's `all` method to get all running processe
 $processes = ChildProcess::all();
 ```
 
-This will return an array of `Native\Laravel\ChildProcess` instances.
+This will return an array of `Native\Desktop\ChildProcess` instances.
 
 ## Stopping a Child Process
 
 Your child processes will shut down when your application exits. However, you may also choose to stop them manually or
 provide this control to your user.
 
-If you have a `Native\Laravel\ChildProcess` instance, you may call the `stop` method on it:
+If you have a `Native\Desktop\ChildProcess` instance, you may call the `stop` method on it:
 
 ```php
 $tail->stop();
@@ -196,7 +196,7 @@ Note that [persistent processes](/docs/digging-deeper/child-processes#persistent
 As a convenience, you may simply restart a Child Process using the `restart` method. This may be useful in cases where
 the program has become unresponsive and you simply need to "reboot" it.
 
-If you have a `Native\Laravel\ChildProcess` instance, you may call the `restart` method on it:
+If you have a `Native\Desktop\ChildProcess` instance, you may call the `restart` method on it:
 
 ```php
 $tail->restart();
@@ -212,10 +212,10 @@ ChildProcess::restart('tail');
 
 There are multiple ways to provide input to your Child Process:
 
--   The environment.
--   Arguments to the command.
--   Its standard input stream (`STDIN`).
--   A custom interface, e.g. a network socket.
+- The environment.
+- Arguments to the command.
+- Its standard input stream (`STDIN`).
+- A custom interface, e.g. a network socket.
 
 Which you use will depend on what the program is capable of handling.
 
@@ -266,10 +266,10 @@ The message format and how they are handled will be determined by the program yo
 
 A Child Process may send output via any of the following interfaces:
 
--   Its standard output stream (`STDOUT`).
--   Its standard error stream (`STDERR`).
--   A custom interface, e.g. a network socket.
--   Broadcasting a Custom Event
+- Its standard output stream (`STDOUT`).
+- Its standard error stream (`STDERR`).
+- A custom interface, e.g. a network socket.
+- Broadcasting a Custom Event
 
 `STDOUT`, `STDERR` & [Custom Events](/docs/digging-deeper/broadcasting#custom-events) are dispatched using
 Laravel's event system.
@@ -297,7 +297,7 @@ All events get dispatched as regular Laravel events, so you may use your `AppSer
 
 ```php
 use Illuminate\Support\Facades\Event;
-use Native\Laravel\Events\ChildProcess\MessageReceived;
+use Native\Desktop\Events\ChildProcess\MessageReceived;
 
 /**
  * Bootstrap any application services.
@@ -317,37 +317,37 @@ Sometimes you may want to listen and react to these events in real-time, which i
 Child Process events to the `nativephp` broadcast channel. Any events broadcasted this way also get dispatched over IPC, enabling you to react to them on the front-end without using websockets.
 
 ```js
-Native.on("Native\\Laravel\\Events\\ChildProcess\\MessageReceived", (event) => {
-    if (event.alias === "tail") {
-        container.append(event.data);
+Native.on('Native\\Desktop\\Events\\ChildProcess\\MessageReceived', (event) => {
+    if (event.alias === 'tail') {
+        container.append(event.data)
     }
-});
+})
 ```
 
 To learn more about NativePHP's broadcasting capabilities, please refer to the
 [Broadcasting](/docs/digging-deeper/broadcasting) section.
 
 ### `ProcessSpawned`
 
-This `Native\Laravel\Events\ChildProcess\ProcessSpawned` event will be dispatched when a Child Process has successfully
+This `Native\Desktop\Events\ChildProcess\ProcessSpawned` event will be dispatched when a Child Process has successfully
 been spawned. The payload of the event contains the `$alias` and the `$pid` of the process.
 
 **In Electron, the `$pid` here will be the Process ID of an Electron Helper process which spawns the underlying
 process.**
 
 ### `ProcessExited`
 
-This `Native\Laravel\Events\ChildProcess\ProcessExited` event will be dispatched when a Child Process exits. The
+This `Native\Desktop\Events\ChildProcess\ProcessExited` event will be dispatched when a Child Process exits. The
 payload of the event contains the `$alias` of the process and its exit `$code`.
 
 ### `MessageReceived`
 
-This `Native\Laravel\Events\ChildProcess\MessageReceived` event will be dispatched when the Child Process emits some
+This `Native\Desktop\Events\ChildProcess\MessageReceived` event will be dispatched when the Child Process emits some
 output via its standard output stream (`STDOUT`). The payload of the event contains the `$alias` of the process and the
 message `$data`.
 
 ### `ErrorReceived`
 
-This `Native\Laravel\Events\ChildProcess\ErrorReceived` event will be dispatched when the Child Process emits an error
+This `Native\Desktop\Events\ChildProcess\ErrorReceived` event will be dispatched when the Child Process emits an error
 via its standard error stream (`STDERR`). The payload of the event contains the `$alias` of the process and the
 error `$data`.

resources/views/docs/desktop/2/digging-deeper/queues.md

@@ -2,25 +2,29 @@
 title: Queues
 order: 500
 ---
+
 # Queues
 
 Queueing tasks to be run in the background is a critical part of creating a great user experience.
 
 NativePHP has built-in support for Laravel's [Queues](https://laravel.com/docs/queues).
 
 ## Queueing a job
+
 If you're familiar with queueing jobs in Laravel, you should feel right at home. There's nothing special you need to do.
 
 Jobs live in the SQLite [database](/docs/digging-deeper/databases) that your app uses by default and the `jobs` table
 migration will have been created and migrated for you.
 
 ## Processing Jobs / Working the Queue
+
 By default, NativePHP will boot up a single queue worker which will consume jobs from the `default` queue.
 
 If you wish to modify the configuration of this worker or run more workers, see [Configuring workers](#configuring-workers).
 
 ### Configuring workers
-Once you publish the NativePHP config file using `php artisan vendor:publish`, you will find a `queue_workers` key in 
+
+Once you publish the NativePHP config file using `php artisan vendor:publish`, you will find a `queue_workers` key in
 `config/nativephp.php`. Here are some acceptable values to get you started:
 
 ```php
@@ -65,7 +69,7 @@ and stop workers, should you need to.
 
 ```php
 use Native\DTOs\QueueConfig;
-use Native\Laravel\Facades\QueueWorker;
+use Native\Desktop\Facades\QueueWorker;
 
 $queueConfig = new QueueConfig(alias: 'manual', queuesToConsume: ['default'], memoryLimit: 1024, timeout: 600);
 
@@ -79,6 +83,7 @@ QueueWorker::down(alias: 'manual');
 ```
 
 ## When to Queue
+
 Given that your database and application typically exist on the same machine (i.e. there's no network involved),
 queueing background tasks can mostly be left for very intense operations and when making API calls over the network.
 

resources/views/docs/desktop/2/getting-started/configuration.md

@@ -3,8 +3,7 @@ title: Configuration
 order: 200
 ---
 
-
-The `native:install` command publishes a configuration file to `config/nativephp.php`. 
+The `native:install` command publishes a configuration file to `config/nativephp.php`.
 This file contains all the configuration options for NativePHP.
 
 ## Default Configuration File
@@ -40,12 +39,12 @@ return [
      * The author of your application.
      */
     'author' => env('NATIVEPHP_APP_AUTHOR'),
-    
+
     /**
      * The copyright notice for your application.
      */
     'copyright' => env('NATIVEPHP_APP_COPYRIGHT'),
-    
+
     /**
      * The description of your application.
      */
@@ -152,8 +151,8 @@ This method should return an array of php.ini directives to be set.
 ```php
 namespace App\Providers;
 
-use Native\Laravel\Facades\Window;
-use Native\Laravel\Contracts\ProvidesPhpIni;
+use Native\Desktop\Facades\Window;
+use Native\Desktop\Contracts\ProvidesPhpIni;
 
 class NativeAppServiceProvider implements ProvidesPhpIni
 {

resources/views/docs/desktop/2/publishing/updating.md

@@ -82,9 +82,9 @@ How to setup your storage and generate the relevant API credentials:
 - Amazon S3 - See [this video](https://www.youtube.com/watch?v=FLIp6BLtwjk&ab_channel=CloudCasts) by Chris Fidao or
   this [Step 2](https://www.twilio.com/docs/video/tutorials/storing-aws-s3#step-2) of this article by Twilio
 
-  If you got the error message "The bucket does not allow ACLs" you can follow this guide
-  from [Learn AWS](https://www.learnaws.org/2023/08/26/aws-s3-bucket-does-not-allow-acls)
-  on how to setup your bucket correctly.
+    If you got the error message "The bucket does not allow ACLs" you can follow this guide
+    from [Learn AWS](https://www.learnaws.org/2023/08/26/aws-s3-bucket-does-not-allow-acls)
+    on how to setup your bucket correctly.
 
 ## Disabling the updater
 
@@ -100,7 +100,7 @@ NATIVEPHP_UPDATER_ENABLED=false
 You can manually check for updates by calling the `checkForUpdates` method on the `AutoUpdater` facade:
 
 ```php
-use Native\Laravel\Facades\AutoUpdater;
+use Native\Desktop\Facades\AutoUpdater;
 
 AutoUpdater::checkForUpdates();
 ```
@@ -113,7 +113,7 @@ will download the update two times.
 You can quit the application and install the update by calling the `quitAndInstall` method on the `AutoUpdater` facade:
 
 ```php
-use Native\Laravel\Facades\AutoUpdater;
+use Native\Desktop\Facades\AutoUpdater;
 
 AutoUpdater::quitAndInstall();
 ```
@@ -127,21 +127,21 @@ application starts.
 
 ### `CheckingForUpdate`
 
-The `Native\Laravel\Events\AutoUpdater\CheckingForUpdate` event is dispatched when checking for an available update has
+The `Native\Desktop\Events\AutoUpdater\CheckingForUpdate` event is dispatched when checking for an available update has
 started.
 
 ### `UpdateAvailable`
 
-The `Native\Laravel\Events\AutoUpdater\UpdateAvailable` event is dispatched when there is an available update. The
+The `Native\Desktop\Events\AutoUpdater\UpdateAvailable` event is dispatched when there is an available update. The
 update is downloaded automatically.
 
 ### `UpdateNotAvailable`
 
-The `Native\Laravel\Events\AutoUpdater\UpdateNotAvailable` event is dispatched when there is no available update.
+The `Native\Desktop\Events\AutoUpdater\UpdateNotAvailable` event is dispatched when there is no available update.
 
 ### `DownloadProgress`
 
-The `Native\Laravel\Events\AutoUpdater\DownloadProgress` event is dispatched when the update is being downloaded.
+The `Native\Desktop\Events\AutoUpdater\DownloadProgress` event is dispatched when the update is being downloaded.
 
 The event contains the following properties:
 
@@ -153,7 +153,7 @@ The event contains the following properties:
 
 ### `UpdateDownloaded`
 
-The `Native\Laravel\Events\AutoUpdater\UpdateDownloaded` event is dispatched when the update has been downloaded.
+The `Native\Desktop\Events\AutoUpdater\UpdateDownloaded` event is dispatched when the update has been downloaded.
 
 The event contains the following properties:
 
@@ -165,7 +165,7 @@ The event contains the following properties:
 
 ### `Error`
 
-The `Native\Laravel\Events\AutoUpdater\Error` event is dispatched when there is an error while updating.
+The `Native\Desktop\Events\AutoUpdater\Error` event is dispatched when there is an error while updating.
 
 The event contains the following properties:
 

resources/views/docs/desktop/2/testing/basics.md

@@ -2,14 +2,16 @@
 title: Basics
 order: 99
 ---
+
 # Understanding fake test doubles
+
 When working with a NativePHP application, you may encounter an elevated level of difficulty when writing tests for your code.
 This is because NativePHP relies on an Electron/Tauri application to be open at all times, listening to HTTP requests. Obviously,
 emulating this in a test environment can be cumbersome. You will often hit an HTTP error, and this is normal. This is where
 NativePHP's fake test doubles come in.
 
 ```php
-use Native\Laravel\Facades\Window;
+use Native\Desktop\Facades\Window;
 
 #[\PHPUnit\Framework\Attributes\Test]
 public function example(): void
@@ -26,5 +28,5 @@ public function example(): void
 
 If you've ever written tests for a Laravel application, you may have seen the `*::fake()` method available on
 all sorts of facades. Under the hood, these methods are swapping the real implementation and behavior – in NativePHP's case,
-an HTTP call that forces us to keep the server up and running, in turn degrading the ability to write expressive tests – with a fake one 
+an HTTP call that forces us to keep the server up and running, in turn degrading the ability to write expressive tests – with a fake one
 that follows the same API. This means you do not have to change any of your code to write great tests.