Add OS info interfaces to readme

SerafimArts · SerafimArts · commit a3047aa4a837 · 2025-08-15T20:39:17.000Z
diff --git a/composer.json b/composer.json
@@ -31,8 +31,7 @@
         "boson-php/uri-factory-contracts": "^0.16",
         "ffi/env": "^1.0",
         "psr/event-dispatcher": "^1.0",
-        "react/promise": "^3.0",
-        "revolt/event-loop": "^1.0"
+        "react/promise": "^3.0"
     },
     "autoload": {
         "psr-4": {
diff --git a/src/Application.php b/src/Application.php
@@ -26,12 +26,14 @@
 use Boson\Internal\BootHandler\WindowsDetachConsoleBootHandler;
 use Boson\Internal\DeferRunner\DeferRunnerInterface;
 use Boson\Internal\DeferRunner\NativeShutdownFunctionRunner;
+use Boson\Internal\Poller\SaucerPoller;
 use Boson\Internal\QuitHandler\PcntlQuitHandler;
 use Boson\Internal\QuitHandler\QuitHandlerInterface;
 use Boson\Internal\QuitHandler\WindowsQuitHandler;
 use Boson\Internal\Saucer\Saucer;
 use Boson\Internal\Saucer\SaucerInterface;
 use Boson\Internal\ThreadsCountResolver;
+use Boson\Poller\PollerInterface;
 use Boson\Shared\Marker\BlockingOperation;
 use Boson\Shared\Marker\RequiresDealloc;
 use Boson\WebView\WebView;
@@ -40,7 +42,6 @@
 use Boson\Window\Window;
 use FFI\CData;
 use Psr\EventDispatcher\EventDispatcherInterface;
-use Revolt\EventLoop;
 
 /**
  * @template-implements IdentifiableInterface<ApplicationId>
@@ -165,6 +166,11 @@ class Application implements
      */
     private readonly EventListener $listener;
 
+    /**
+     * An application poller interface.
+     */
+    public readonly PollerInterface $poller;
+
     /**
      * @param EventDispatcherInterface|null $dispatcher an optional event
      *        dispatcher for handling application events
@@ -208,6 +214,7 @@ public function __construct(
         $this->api = $this->createLibSaucer($info->library, $this->os->family, $this->cpu->arch);
         $this->id = $this->createApplicationId($this->api, $this->info->name, $this->info->threads);
         $this->windows = $this->createWindowManager($this->api, $this, $info, $this->listener);
+        $this->poller = $this->createApplicationPoller($this->api);
 
         // Initialization of Application's API
         $this->dialog = new ApplicationDialog($this->api, $this, $this->listener);
@@ -222,6 +229,14 @@ public function __construct(
         $this->boot();
     }
 
+    /**
+     * Create an application event-loop.
+     */
+    protected function createApplicationPoller(SaucerInterface $saucer): PollerInterface
+    {
+        return new SaucerPoller($this->id, $saucer);
+    }
+
     /**
      * Creates a new instance of {@see SaucerInterface} that provides access to the
      * native WebView API library. The returned object allows interacting with
@@ -501,17 +516,9 @@ public function run(): void
 
         $this->listener->dispatch(new ApplicationStarted($this));
 
-        EventLoop::repeat(0, function (string $id): void {
-            if ($this->isRunning === false) {
-                EventLoop::cancel($id);
-
-                return;
-            }
-
-            $this->api->saucer_application_run_once($this->id->ptr);
-        });
-
-        EventLoop::run();
+        while ($this->isRunning) {
+            $this->poller->next();
+        }
     }
 
     /**
diff --git a/src/Internal/Poller/SaucerPoller.php b/src/Internal/Poller/SaucerPoller.php
@@ -0,0 +1,121 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Boson\Internal\Poller;
+
+use Boson\ApplicationId;
+use Boson\Internal\Saucer\SaucerInterface;
+use Boson\Poller\PollerInterface;
+use Boson\Shared\IdValueGenerator\IdValueGeneratorInterface;
+use Boson\Shared\IdValueGenerator\PlatformDependentIntValueGenerator;
+use FFI\CData;
+
+/**
+ * @api
+ *
+ * @internal this is an internal library class, please do not use it in your code
+ * @psalm-internal Boson
+ */
+final class SaucerPoller implements PollerInterface
+{
+    /**
+     * @var array<array-key, \Closure(array-key):void>
+     */
+    private array $queueTasks = [];
+
+    /**
+     * @var array<array-key, \Closure(array-key):void>
+     */
+    private array $periodicTasks = [];
+
+    private TaskType $type = TaskType::Internal;
+
+    private readonly IdValueGeneratorInterface $ids;
+
+    private readonly CData $ptr;
+
+    public function __construct(
+        private readonly ApplicationId $id,
+        private readonly SaucerInterface $saucer,
+    ) {
+        $this->ids = new PlatformDependentIntValueGenerator();
+        $this->ptr = $this->id->ptr;
+    }
+
+    public function next(): void
+    {
+        switch ($this->type) {
+            case TaskType::Internal:
+                $this->executeInternalTask();
+                break;
+
+            case TaskType::Periodic:
+                $this->executePeriodicTask();
+                break;
+
+            case TaskType::Queued:
+                $this->executeQueuedTask();
+                break;
+        }
+
+        $this->type = $this->type->next();
+    }
+
+    private function executeInternalTask(): void
+    {
+        $this->saucer->saucer_application_run_once($this->ptr);
+    }
+
+    private function executePeriodicTask(): void
+    {
+        foreach ($this->periodicTasks as $id => $task) {
+            $task($id);
+
+            return;
+        }
+    }
+
+    private function executeQueuedTask(): void
+    {
+        foreach ($this->queueTasks as $id => $task) {
+            unset($this->queueTasks[$id]);
+
+            $task($id);
+
+            return;
+        }
+    }
+
+    public function defer(callable $task): int|string
+    {
+        $this->queueTasks[$id = $this->ids->nextId()] = $task(...);
+
+        return $id;
+    }
+
+    public function repeat(callable $task): int|string
+    {
+        $this->periodicTasks[$id = $this->ids->nextId()] = $task(...);
+
+        return $id;
+    }
+
+    public function delay(float $delay, callable $task): int|string
+    {
+        $stopsAfter = \microtime(true) + $delay;
+
+        return $this->repeat(function (string $taskId) use ($stopsAfter, $task): void {
+            if (\microtime(true) > $stopsAfter) {
+                $task($taskId);
+
+                $this->cancel($taskId);
+            }
+        });
+    }
+
+    public function cancel(int|string $taskId): void
+    {
+        unset($this->queueTasks[$taskId]);
+    }
+}
diff --git a/src/Internal/Poller/TaskType.php b/src/Internal/Poller/TaskType.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Boson\Internal\Poller;
+
+enum TaskType
+{
+    case Internal;
+    case Periodic;
+    case Queued;
+
+    public function next(): self
+    {
+        return match ($this) {
+            self::Internal => self::Periodic,
+            self::Periodic => self::Queued,
+            self::Queued => self::Internal,
+        };
+    }
+}
diff --git a/src/Poller/PollerInterface.php b/src/Poller/PollerInterface.php
@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Boson\Poller;
+
+interface PollerInterface
+{
+    /**
+     * Poll next application loop event.
+     */
+    public function next(): void;
+
+    /**
+     * Defer the execution of a callback.
+     *
+     * @template TArgTaskId of array-key
+     *
+     * @param callable(TArgTaskId):void $task The callback to defer.
+     *
+     * @return TArgTaskId An unique identifier that can be used to cancel
+     *         the callback.
+     */
+    public function defer(callable $task): int|string;
+
+    /**
+     * Repeatedly execute a callback.
+     *
+     * @template TArgTaskId of array-key
+     *
+     * @param callable(TArgTaskId):void $task The callback to execute.
+     *
+     * @return TArgTaskId An unique identifier that can be used to cancel
+     *         the callback.
+     */
+    public function repeat(callable $task): int|string;
+
+    /**
+     * Delay the execution of a callback.
+     *
+     * @template TArgTaskId of array-key
+     *
+     * @param float $delay The amount of time, in seconds, to delay the execution for.
+     * @param callable(TArgTaskId):void $task The callback to delay.
+     *
+     * @return TArgTaskId A unique identifier that can be used to
+     *         cancel the callback.
+     */
+    public function delay(float $delay, callable $task): int|string;
+
+    /**
+     * Cancel a task.
+     *
+     * This will detach the event loop from all resources that are associated
+     * to the callback. After this operation the callback is permanently
+     * invalid. Calling this function MUST NOT fail, even if passed an invalid
+     * identifier.
+     *
+     * @param array-key $taskId The callback identifier.
+     */
+    public function cancel(int|string $taskId): void;
+}
diff --git a/src/WebView/Api/Data/WebViewData.php b/src/WebView/Api/Data/WebViewData.php
@@ -19,7 +19,6 @@
 use JetBrains\PhpStorm\Language;
 use React\Promise\Deferred;
 use React\Promise\PromiseInterface;
-use Revolt\EventLoop;
 
 use function React\Promise\resolve;
 
@@ -146,29 +145,34 @@ public function get(#[Language('JavaScript')] string $code, ?float $timeout = nu
             throw ApplicationNotRunningException::becauseApplicationNotRunning($code);
         }
 
-        $suspension = EventLoop::getSuspension();
+        $isProcessed = false;
+        $result = null;
 
         $this->defer($code)
-            ->then(static function (mixed $input) use ($suspension): mixed {
-                $suspension->resume($input);
+            ->then(static function (mixed $input) use (&$isProcessed, &$result): mixed {
+                $isProcessed = true;
+                $result = $input;
 
                 return $input;
             })
-            ->catch(static function (\Throwable $e) use ($suspension): \Throwable {
-                $suspension->throw($e);
+            ->catch(static function (\Throwable $e) use (&$isProcessed, &$result): \Throwable {
+                $isProcessed = true;
+                $result = $e;
 
                 return $e;
             });
 
         $timeout ??= $this->timeout;
 
-        $delayId = EventLoop::delay($timeout, function () use ($code, $timeout): void {
+        $poller = $this->context->window->app->poller;
+
+        $poller->delay($timeout, function () use ($code, $timeout): void {
             throw StalledRequestException::becauseRequestIsStalled($code, $timeout);
         });
 
-        $result = $suspension->suspend();
-
-        EventLoop::cancel($delayId);
+        while ($isProcessed === false) {
+            $poller->next();
+        }
 
         return $result;
     }
diff --git a/src/WebView/Api/Schemes/WebViewSchemeHandler.php b/src/WebView/Api/Schemes/WebViewSchemeHandler.php
@@ -17,7 +17,6 @@
 use Boson\WebView\Internal\WebViewSchemeHandler\MimeTypeReader;
 use Boson\WebView\WebView;
 use FFI\CData;
-use Revolt\EventLoop;
 
 final class WebViewSchemeHandler extends WebViewExtension implements SchemesApiInterface
 {
@@ -63,7 +62,7 @@ private function onSafeRequest(CData $_, CData $request, CData $executor): void
             $code = SaucerSchemeError::SAUCER_REQUEST_ERROR_FAILED;
             $this->api->saucer_scheme_executor_reject($executor, $code);
 
-            EventLoop::defer(static function () use ($e) {
+            $this->context->window->app->poller->defer(static function () use ($e) {
                 throw $e;
             });
 
diff --git a/src/WebView/Internal/SaucerWebViewEventHandler.php b/src/WebView/Internal/SaucerWebViewEventHandler.php
diff --git a/tests/Stub/TestingApplicationStub.php b/tests/Stub/TestingApplicationStub.php
