jaxon-php / jaxon-mono

jaxon-core/src/App/View/ViewInterface.php

Switch Indentation +4 added lines, -4 removed lines

@@ -4,7 +4,7 @@ 
 
 interface ViewInterface
 {
-    /**
+/**
      * Add a namespace to the view renderer
      *
      * @param string $sNamespace    The namespace name
@@ -13,14 +13,14 @@ 
      *
      * @return void
      */
-    public function addNamespace(string $sNamespace, string $sDirectory, string $sExtension = ''): void;
+public function addNamespace(string $sNamespace, string $sDirectory, string $sExtension = ''): void;
 
-    /**
+/**
      * Render a view
      *
      * @param Store $store    A store populated with the view data
      *
      * @return string
      */
-    public function render(Store $store): string;
+public function render(Store $store): string;
 }

jaxon-core/src/App/View/Helper/EventAttr.php

Switch Indentation +38 added lines, -38 removed lines

@@ -23,33 +23,33 @@ 
 
 class EventAttr
 {
-    /**
+/**
      * @var array
      */
-    private array $aHandlers = [];
+private array $aHandlers = [];
 
-    /**
+/**
      * The constructor
      *
      * @param string $sSelector
      */
-    public function __construct(private string $sSelector)
-    {}
+public function __construct(private string $sSelector)
+{}
 
-    /**
+/**
      * Set a selector for the next event handler
      *
      * @param string $sSelector
      *
      * @return self
      */
-    public function select(string $sSelector): self
-    {
-        $this->sSelector = trim($sSelector);
-        return $this;
-    }
+public function select(string $sSelector): self
+{
+$this->sSelector = trim($sSelector);
+return $this;
+}
 
-    /**
+/**
      * Set an event handler with the "on" keyword
      *
      * @param string $event
@@ -57,43 +57,43 @@ 
      *
      * @return self
      */
-    public function on(string $event, JsExpr $xJsExpr): self
-    {
-        if($this->sSelector === '')
-        {
-            return $this;
-        }
+public function on(string $event, JsExpr $xJsExpr): self
+{
+if($this->sSelector === '')
+{
+return $this;
+}
 
-        $this->aHandlers[] = [
-            'select' => $this->sSelector,
-            'event' => trim($event),
-            'handler' => $xJsExpr,
-        ];
-        $this->sSelector = '';
-        return $this;
-    }
+$this->aHandlers[] = [
+'select' => $this->sSelector,
+'event' => trim($event),
+'handler' => $xJsExpr,
+];
+$this->sSelector = '';
+return $this;
+}
 
-    /**
+/**
      * Shortcut to set a click event handler
      *
      * @param JsExpr $xJsExpr
      *
      * @return self
      */
-    public function click(JsExpr $xJsExpr): self
-    {
-        return $this->on('click', $xJsExpr);
-    }
+public function click(JsExpr $xJsExpr): self
+{
+return $this->on('click', $xJsExpr);
+}
 
-    /**
+/**
      * Convert to string.
      *
      * @return string
      */
-    public function __toString(): string
-    {
-        // No output if no handler is defined.
-        return count($this->aHandlers) === 0 ? '' : 'jxn-event="' .
-            htmlentities(json_encode($this->aHandlers)) . '"';
-    }
+public function __toString(): string
+{
+// No output if no handler is defined.
+return count($this->aHandlers) === 0 ? '' : 'jxn-event="' .
+htmlentities(json_encode($this->aHandlers)) . '"';
+}
 }

jaxon-core/src/App/View/Helper/HtmlAttrHelper.php

Switch Indentation +101 added lines, -101 removed lines

@@ -31,40 +31,40 @@ 
 
 class HtmlAttrHelper
 {
-    /**
+/**
      * @var string|null
      */
-    private string|null $sPaginationComponent = null;
+private string|null $sPaginationComponent = null;
 
-    /**
+/**
      * The constructor
      *
      * @param ComponentContainer $cdi
      */
-    public function __construct(protected ComponentContainer $cdi)
-    {}
+public function __construct(protected ComponentContainer $cdi)
+{}
 
-    /**
+/**
      * Get the component HTML code
      *
      * @param JxnCall $xJsCall
      *
      * @return string
      */
-    public function html(JxnCall $xJsCall): string
-    {
-        $sClassName = $xJsCall->_class();
-        if(!$sClassName)
-        {
-            return '';
-        }
-
-        $xComponent = $this->cdi->makeComponent($sClassName);
-        return is_a($xComponent, NodeComponent::class) ?
-            (string)$xComponent->html() : '';
-    }
-
-    /**
+public function html(JxnCall $xJsCall): string
+{
+$sClassName = $xJsCall->_class();
+if(!$sClassName)
+{
+return '';
+}
+
+$xComponent = $this->cdi->makeComponent($sClassName);
+return is_a($xComponent, NodeComponent::class) ?
+(string)$xComponent->html() : '';
+}
+
+/**
      * Attach a component to a DOM node
      *
      * @param JxnCall $xJsCall
@@ -72,41 +72,41 @@ 
      *
      * @return string
      */
-    public function bind(JxnCall $xJsCall, string $item = ''): string
-    {
-        $item = trim($item);
-        return 'jxn-bind="' . $xJsCall->_class() . (!$item ? '"' : '" jxn-item="' . $item . '"');
-    }
+public function bind(JxnCall $xJsCall, string $item = ''): string
+{
+$item = trim($item);
+return 'jxn-bind="' . $xJsCall->_class() . (!$item ? '"' : '" jxn-item="' . $item . '"');
+}
 
-    /**
+/**
      * Attach the pagination component to a DOM node
      *
      * @param JxnCall $xJsCall
      *
      * @return string
      */
-    public function pagination(JxnCall $xJsCall): string
-    {
-        // The pagination is always rendered with the same Pagination component.
-        $sComponent = $this->sPaginationComponent ?:
-            ($this->sPaginationComponent = rq(Pagination::class)->_class());
-        $sItem = $xJsCall->_class();
-        return "jxn-bind=\"$sComponent\" jxn-item=\"$sItem\"";
-    }
-
-    /**
+public function pagination(JxnCall $xJsCall): string
+{
+// The pagination is always rendered with the same Pagination component.
+$sComponent = $this->sPaginationComponent ?:
+($this->sPaginationComponent = rq(Pagination::class)->_class());
+$sItem = $xJsCall->_class();
+return "jxn-bind=\"$sComponent\" jxn-item=\"$sItem\"";
+}
+
+/**
      * Set a selector for the next event handler
      *
      * @param string $sSelector
      *
      * @return EventAttr
      */
-    public function select(string $sSelector): EventAttr
-    {
-        return new EventAttr($sSelector);
-    }
+public function select(string $sSelector): EventAttr
+{
+return new EventAttr($sSelector);
+}
 
-    /**
+/**
      * Set an event handler
      *
      * @param string $event
@@ -114,83 +114,83 @@ 
      *
      * @return string
      */
-    public function on(string $event, JsExpr $xJsExpr): string
-    {
-        $event = trim($event);
-        $sCall = htmlentities(json_encode($xJsExpr->jsonSerialize()));
-        return "jxn-on=\"$event\" jxn-call=\"$sCall\"";
-    }
-
-    /**
+public function on(string $event, JsExpr $xJsExpr): string
+{
+$event = trim($event);
+$sCall = htmlentities(json_encode($xJsExpr->jsonSerialize()));
+return "jxn-on=\"$event\" jxn-call=\"$sCall\"";
+}
+
+/**
      * Shortcut to set a click event handler
      *
      * @param JsExpr $xJsExpr
      *
      * @return string
      */
-    public function click(JsExpr $xJsExpr): string
-    {
-        return $this->on('click', $xJsExpr);
-    }
+public function click(JsExpr $xJsExpr): string
+{
+return $this->on('click', $xJsExpr);
+}
 
-    /**
+/**
      * @param array $aHandler
      *
      * @return bool
      */
-    private function eventIsValid(array $aHandler): bool
-    {
-        return count($aHandler) === 3 &&
-            isset($aHandler[0]) && isset($aHandler[1]) && isset($aHandler[2]) &&
-            is_string($aHandler[0]) && is_string($aHandler[1]) &&
-            is_a($aHandler[2], JsExpr::class);
-    }
-
-    /**
+private function eventIsValid(array $aHandler): bool
+{
+return count($aHandler) === 3 &&
+isset($aHandler[0]) && isset($aHandler[1]) && isset($aHandler[2]) &&
+is_string($aHandler[0]) && is_string($aHandler[1]) &&
+is_a($aHandler[2], JsExpr::class);
+}
+
+/**
      * @param array $aHandler
      * @param EventAttr|null $xAttr
      *
      * @return EventAttr|null
      */
-    private function setEventHandler(array $aHandler, ?EventAttr $xAttr = null): EventAttr|null
-    {
-        if(!$this->eventIsValid($aHandler))
-        {
-            return $xAttr;
-        }
-        // The array content is valid.
-        [$sSelector, $sEvent, $xJsExpr] = $aHandler;
-        return !$xAttr ?
-            $this->select($sSelector)->on($sEvent, $xJsExpr) :
-            $xAttr->select($sSelector)->on($sEvent, $xJsExpr);
-    }
-
-    /**
+private function setEventHandler(array $aHandler, ?EventAttr $xAttr = null): EventAttr|null
+{
+if(!$this->eventIsValid($aHandler))
+{
+return $xAttr;
+}
+// The array content is valid.
+[$sSelector, $sEvent, $xJsExpr] = $aHandler;
+return !$xAttr ?
+$this->select($sSelector)->on($sEvent, $xJsExpr) :
+$xAttr->select($sSelector)->on($sEvent, $xJsExpr);
+}
+
+/**
      * Set an event handler
      *
      * @param array $aHandler
      *
      * @return string
      */
-    public function event(array $aHandler): string
-    {
-        return $this->setEventHandler($aHandler)?->__toString() ?? '';
-    }
+public function event(array $aHandler): string
+{
+return $this->setEventHandler($aHandler)?->__toString() ?? '';
+}
 
-    /**
+/**
      * Set event handlers
      *
      * @param array $aHandlers
      *
      * @return string
      */
-    public function events(array $aHandlers): string
-    {
-        return array_reduce($aHandlers, fn(EventAttr|null $xAttr, array $aHandler)
-            => $this->setEventHandler($aHandler, $xAttr), null)?->__toString() ?? '';
-    }
+public function events(array $aHandlers): string
+{
+return array_reduce($aHandlers, fn(EventAttr|null $xAttr, array $aHandler)
+=> $this->setEventHandler($aHandler, $xAttr), null)?->__toString() ?? '';
+}
 
-    /**
+/**
      * Get the HTML or Javascript ready code for a package
      *
      * @param string $sClass
@@ -198,17 +198,17 @@ 
      *
      * @return string
      */
-    public function package(string $sClass, string $sType = 'html'): string
-    {
-        $sCode = match($sType) {
-            'html' => jaxon()->package($sClass)?->getHtml() ?? '',
-            'ready' => jaxon()->package($sClass)?->getReadyScript() ?? '',
-            default => ''
-        };
-        $sCode = trim($sCode);
-
-        return $sType !== 'ready' || $sCode === '' ? $sCode :
-            // Call the ready code with the jaxon.dom.ready function.
-            "jaxon.dom.ready(() => $sCode)";
-    }
+public function package(string $sClass, string $sType = 'html'): string
+{
+$sCode = match($sType) {
+'html' => jaxon()->package($sClass)?->getHtml() ?? '',
+'ready' => jaxon()->package($sClass)?->getReadyScript() ?? '',
+default => ''
+};
+$sCode = trim($sCode);
+
+return $sType !== 'ready' || $sCode === '' ? $sCode :
+// Call the ready code with the jaxon.dom.ready function.
+"jaxon.dom.ready(() => $sCode)";
+}
 }

jaxon-annotations/src/Annotation/ExportAnnotation.php

Switch Indentation +25 added lines, -25 removed lines

@@ -26,41 +26,41 @@
  */
 class ExportAnnotation extends AbstractAnnotation
 {
-    /**
+/**
      * @var array
      */
-    private $aMethods = [];
+private $aMethods = [];
 
-    /**
+/**
      * @inheritDoc
      */
-    public static function parseAnnotation($value)
-    {
-        $aParams = json_decode($value, true);
-        return is_array($aParams) ? $aParams : [];
-    }
+public static function parseAnnotation($value)
+{
+$aParams = json_decode($value, true);
+return is_array($aParams) ? $aParams : [];
+}
 
-    /**
+/**
      * @inheritDoc
      * @throws AnnotationException
      */
-    public function initAnnotation(array $properties)
-    {
-        foreach(['base', 'only', 'except'] as $key)
-        {
-            if(isset($properties[$key]) && is_array($properties[$key]) &&
-                count($properties[$key]) > 0)
-            {
-                $this->aMethods[$key] = $properties[$key];
-            }
-        }
-    }
+public function initAnnotation(array $properties)
+{
+foreach(['base', 'only', 'except'] as $key)
+{
+if(isset($properties[$key]) && is_array($properties[$key]) &&
+    count($properties[$key]) > 0)
+{
+    $this->aMethods[$key] = $properties[$key];
+}
+}
+}
 
-    /**
+/**
      * @inheritDoc
      */
-    public function saveValue(Metadata $xMetadata, string $sMethod = '*'): void
-    {
-        $xMetadata->export($sMethod)->setMethods($this->aMethods);
-    }
+public function saveValue(Metadata $xMetadata, string $sMethod = '*'): void
+{
+$xMetadata->export($sMethod)->setMethods($this->aMethods);
+}
 }

jaxon-core/src/App/Metadata/Data/ExportData.php

Switch Indentation +31 added lines, -31 removed lines

@@ -22,53 +22,53 @@
 
 class ExportData extends AbstractData
 {
-    /**
+/**
      * @var array<string, array<string>>
      */
-    private array $aMethods = [];
+private array $aMethods = [];
 
-    /**
+/**
      * @return string
      */
-    public function getName(): string
-    {
-        return 'export';
-    }
+public function getName(): string
+{
+return 'export';
+}
 
-    /**
+/**
      * @return mixed
      */
-    public function getValue(): mixed
-    {
-        return $this->aMethods;
-    }
+public function getValue(): mixed
+{
+return $this->aMethods;
+}
 
-    /**
+/**
      * @param array $aMethods
      *
      * @return void
      */
-    public function setMethods(array $aMethods): void
+public function setMethods(array $aMethods): void
+{
+foreach(['base', 'only', 'except'] as $sKey)
+{
+foreach($aMethods[$sKey] ?? [] as $sMethod)
+{
+    if(!is_string($sMethod) || !$this->validateMethod($sMethod))
     {
-        foreach(['base', 'only', 'except'] as $sKey)
-        {
-            foreach($aMethods[$sKey] ?? [] as $sMethod)
-            {
-                if(!is_string($sMethod) || !$this->validateMethod($sMethod))
-                {
-                    throw new SetupException("'$sMethod' is not a valid method name.");
-                }
-            }
-        }
-        $this->aMethods = $aMethods;
+        throw new SetupException("'$sMethod' is not a valid method name.");
     }
+}
+}
+$this->aMethods = $aMethods;
+}
 
-    /**
+/**
      * @inheritDoc
      */
-    public function encode(string $sVarName): array
-    {
-        $sMethods = addslashes(json_encode($this->aMethods));
-        return ["{$sVarName}->setMethods(json_decode(\"$sMethods\", true));"];
-    }
+public function encode(string $sVarName): array
+{
+$sMethods = addslashes(json_encode($this->aMethods));
+return ["{$sVarName}->setMethods(json_decode(\"$sMethods\", true));"];
+}
 }

jaxon-core/src/Plugin/Request/CallableClass/ComponentOptions.php

Switch Indentation +169 added lines, -169 removed lines

@@ -34,224 +34,224 @@ 
 
 class ComponentOptions
 {
-    /**
+/**
      * Check if the js code for this object must be generated
      *
      * @var bool
      */
-    private $bExcluded = false;
+private $bExcluded = false;
 
-    /**
+/**
      * The character to use as separator in javascript class names
      *
      * @var string
      */
-    private $sSeparator = '.';
+private $sSeparator = '.';
 
-    /**
+/**
      * A list of methods of the user registered callable object the library can export to javascript
      *
      * @var array
      */
-    private $aPublicMethods = [];
+private $aPublicMethods = [];
 
-    /**
+/**
      * The methods in the export attributes
      *
      * @var array
      */
-    private $aExportMethods = ['except' => []];
+private $aExportMethods = ['except' => []];
 
-    /**
+/**
      * A list of methods to call before processing the request
      *
      * @var array
      */
-    private $aBeforeMethods = [];
+private $aBeforeMethods = [];
 
-    /**
+/**
      * A list of methods to call after processing the request
      *
      * @var array
      */
-    private $aAfterMethods = [];
+private $aAfterMethods = [];
 
-    /**
+/**
      * The javascript class options
      *
      * @var array
      */
-    private $aJsOptions = [];
+private $aJsOptions = [];
 
-    /**
+/**
      * The DI options
      *
      * @var array
      */
-    private $aDiOptions = [];
+private $aDiOptions = [];
 
-    /**
+/**
      * The constructor
      *
      * @param array $aMethods
      * @param array $aOptions
      * @param Metadata|null $xMetadata
      */
-    public function __construct(array $aMethods, array $aOptions, Metadata|null $xMetadata)
-    {
-        $this->bExcluded = ($xMetadata?->isExcluded() ?? false) ||
-            (bool)($aOptions['excluded'] ?? false);
-
-        // Options from the config.
-        $sSeparator = $aOptions['separator'] ?? '.';
-        $this->sSeparator = $sSeparator === '_' ? '_' : '.';
-        $this->addProtectedMethods($aOptions['protected'] ?? []);
-        foreach($aOptions['functions'] ?? [] as $sNames => $aFunctionOptions)
-        {
-            // Names are in a comma-separated list.
-            $aFunctionNames = explode(',', $sNames);
-            foreach($aFunctionNames as $sFunctionName)
-            {
-                $this->addFunctionOptions($sFunctionName, $aFunctionOptions);
-            }
-        }
+public function __construct(array $aMethods, array $aOptions, Metadata|null $xMetadata)
+{
+$this->bExcluded = ($xMetadata?->isExcluded() ?? false) ||
+(bool)($aOptions['excluded'] ?? false);
+
+// Options from the config.
+$sSeparator = $aOptions['separator'] ?? '.';
+$this->sSeparator = $sSeparator === '_' ? '_' : '.';
+$this->addProtectedMethods($aOptions['protected'] ?? []);
+foreach($aOptions['functions'] ?? [] as $sNames => $aFunctionOptions)
+{
+// Names are in a comma-separated list.
+$aFunctionNames = explode(',', $sNames);
+foreach($aFunctionNames as $sFunctionName)
+{
+    $this->addFunctionOptions($sFunctionName, $aFunctionOptions);
+}
+}
 
-        // Options from the attributes or annotations.
-        if($xMetadata !== null)
-        {
-            $this->readMetadataOptions($xMetadata);
-        }
+// Options from the attributes or annotations.
+if($xMetadata !== null)
+{
+$this->readMetadataOptions($xMetadata);
+}
 
-        $this->aPublicMethods = $this->filterPublicMethods($aMethods);
-    }
+$this->aPublicMethods = $this->filterPublicMethods($aMethods);
+}
 
-    /**
+/**
      * @param array|string $xMethods
      *
      * @return void
      */
-    private function addProtectedMethods(array|string $xMethods): void
-    {
-        $this->aExportMethods['except'] = array_merge($this->aExportMethods['except'],
-            !is_array($xMethods) ? [trim((string)$xMethods)] :
-            array_map(fn($sMethod) => trim((string)$sMethod), $xMethods));
-    }
+private function addProtectedMethods(array|string $xMethods): void
+{
+$this->aExportMethods['except'] = array_merge($this->aExportMethods['except'],
+!is_array($xMethods) ? [trim((string)$xMethods)] :
+array_map(fn($sMethod) => trim((string)$sMethod), $xMethods));
+}
 
-    /**
+/**
      * @param Metadata $xMetadata
      *
      * @return void
      */
-    private function readMetadataOptions(Metadata $xMetadata): void
-    {
-        // Excluded methods must be merged with the existing ones.
-        $aExportMethods = $xMetadata->getExportMethods();
-        $aExportMethods['except'] = array_unique(array_merge(
-            $aExportMethods['except'] ?? [], $this->aExportMethods['except']));
-        $this->aExportMethods = $aExportMethods;
-        foreach($xMetadata->getProperties() as $sFunctionName => $aFunctionOptions)
-        {
-            $this->addFunctionOptions($sFunctionName, $aFunctionOptions);
-        }
-    }
+private function readMetadataOptions(Metadata $xMetadata): void
+{
+// Excluded methods must be merged with the existing ones.
+$aExportMethods = $xMetadata->getExportMethods();
+$aExportMethods['except'] = array_unique(array_merge(
+$aExportMethods['except'] ?? [], $this->aExportMethods['except']));
+$this->aExportMethods = $aExportMethods;
+foreach($xMetadata->getProperties() as $sFunctionName => $aFunctionOptions)
+{
+$this->addFunctionOptions($sFunctionName, $aFunctionOptions);
+}
+}
 
-    /**
+/**
      * @param array $aMethods
      *
      * @return array
      */
-    private function filterPublicMethods(array $aMethods): array
-    {
-        if($this->bExcluded || in_array('*', $this->aExportMethods['except']))
-        {
-            return [];
-        }
+private function filterPublicMethods(array $aMethods): array
+{
+if($this->bExcluded || in_array('*', $this->aExportMethods['except']))
+{
+return [];
+}
 
-        $aBaseMethods = $aMethods[1];
-        $aNoMethods = $aMethods[2];
-        $aMethods = $aMethods[0];
-        if(isset($this->aExportMethods['only']))
-        {
-            $aMethods = array_intersect($aMethods, $this->aExportMethods['only']);
-        }
-        $aMethods = array_diff($aMethods, $this->aExportMethods['except']);
-        if(count($aBaseMethods) > 0 && isset($this->aExportMethods['base']))
-        {
-            $aBaseMethods = array_diff($aBaseMethods, $this->aExportMethods['base']);
-        }
+$aBaseMethods = $aMethods[1];
+$aNoMethods = $aMethods[2];
+$aMethods = $aMethods[0];
+if(isset($this->aExportMethods['only']))
+{
+$aMethods = array_intersect($aMethods, $this->aExportMethods['only']);
+}
+$aMethods = array_diff($aMethods, $this->aExportMethods['except']);
+if(count($aBaseMethods) > 0 && isset($this->aExportMethods['base']))
+{
+$aBaseMethods = array_diff($aBaseMethods, $this->aExportMethods['base']);
+}
 
-        return array_values(array_diff($aMethods, $aBaseMethods, $aNoMethods));
-    }
+return array_values(array_diff($aMethods, $aBaseMethods, $aNoMethods));
+}
 
-    /**
+/**
      * @return array
      */
-    public function getPublicMethods(): array
-    {
-        return $this->aPublicMethods;
-    }
+public function getPublicMethods(): array
+{
+return $this->aPublicMethods;
+}
 
-    /**
+/**
      * @param string $sMethodName
      *
      * @return bool
      */
-    public function isPublicMethod(string $sMethodName): bool
-    {
-        return in_array($sMethodName, $this->aPublicMethods);
-    }
+public function isPublicMethod(string $sMethodName): bool
+{
+return in_array($sMethodName, $this->aPublicMethods);
+}
 
-    /**
+/**
      * Check if the js code for this object must be generated
      *
      * @return bool
      */
-    public function excluded(): bool
-    {
-        return $this->bExcluded;
-    }
+public function excluded(): bool
+{
+return $this->bExcluded;
+}
 
-    /**
+/**
      * @return string
      */
-    public function separator(): string
-    {
-        return $this->sSeparator;
-    }
+public function separator(): string
+{
+return $this->sSeparator;
+}
 
-    /**
+/**
      * @return array
      */
-    public function beforeMethods(): array
-    {
-        return $this->aBeforeMethods;
-    }
+public function beforeMethods(): array
+{
+return $this->aBeforeMethods;
+}
 
-    /**
+/**
      * @return array
      */
-    public function afterMethods(): array
-    {
-        return $this->aAfterMethods;
-    }
+public function afterMethods(): array
+{
+return $this->aAfterMethods;
+}
 
-    /**
+/**
      * @return array
      */
-    public function diOptions(): array
-    {
-        return $this->aDiOptions;
-    }
+public function diOptions(): array
+{
+return $this->aDiOptions;
+}
 
-    /**
+/**
      * @return array
      */
-    public function jsOptions(): array
-    {
-        return $this->aJsOptions;
-    }
+public function jsOptions(): array
+{
+return $this->aJsOptions;
+}
 
-    /**
+/**
      * Set hook methods
      *
      * @param array $aHookMethods    The array of hook methods
@@ -259,36 +259,36 @@ 
      *
      * @return void
      */
-    private function setHookMethods(array &$aHookMethods, $xValue): void
-    {
-        foreach($xValue as $sCalledMethod => $xMethodToCall)
-        {
-            if(!isset($aHookMethods[$sCalledMethod]))
-            {
-                $aHookMethods[$sCalledMethod] = [];
-            }
-            if(is_array($xMethodToCall))
-            {
-                $aHookMethods[$sCalledMethod] =
-                    array_merge($aHookMethods[$sCalledMethod], $xMethodToCall);
-                continue;
-            }
-            if(is_string($xMethodToCall))
-            {
-                $aHookMethods[$sCalledMethod][] = $xMethodToCall;
-            }
-        }
-    }
+private function setHookMethods(array &$aHookMethods, $xValue): void
+{
+foreach($xValue as $sCalledMethod => $xMethodToCall)
+{
+if(!isset($aHookMethods[$sCalledMethod]))
+{
+    $aHookMethods[$sCalledMethod] = [];
+}
+if(is_array($xMethodToCall))
+{
+    $aHookMethods[$sCalledMethod] =
+        array_merge($aHookMethods[$sCalledMethod], $xMethodToCall);
+    continue;
+}
+if(is_string($xMethodToCall))
+{
+    $aHookMethods[$sCalledMethod][] = $xMethodToCall;
+}
+}
+}
 
-    /**
+/**
      * @param array $aDiOptions
      */
-    private function addDiOption(array $aDiOptions): void
-    {
-        $this->aDiOptions = array_merge($this->aDiOptions, $aDiOptions);
-    }
+private function addDiOption(array $aDiOptions): void
+{
+$this->aDiOptions = array_merge($this->aDiOptions, $aDiOptions);
+}
 
-    /**
+/**
      * Set configuration options / call options for each method
      *
      * @param string $sName    The name of the configuration option
@@ -296,25 +296,25 @@ 
      *
      * @return void
      */
-    private function addOption(string $sName, $xValue): void
-    {
-        switch($sName)
-        {
-        // Set the methods to call before processing the request
-        case '__before':
-            $this->setHookMethods($this->aBeforeMethods, $xValue);
-            break;
-        // Set the methods to call after processing the request
-        case '__after':
-            $this->setHookMethods($this->aAfterMethods, $xValue);
-            break;
-        // Set the attributes to inject in the callable object
-        case '__di':
-            $this->addDiOption($xValue);
-            break;
-        default:
-            break;
-        }
+private function addOption(string $sName, $xValue): void
+{
+switch($sName)
+{
+// Set the methods to call before processing the request
+case '__before':
+$this->setHookMethods($this->aBeforeMethods, $xValue);
+break;
+// Set the methods to call after processing the request
+case '__after':
+$this->setHookMethods($this->aAfterMethods, $xValue);
+break;
+// Set the attributes to inject in the callable object
+case '__di':
+$this->addDiOption($xValue);
+break;
+default:
+break;
+}
     }
 
     /**

jaxon-annotations/src/AnnotationReader.php

Switch Indentation +152 added lines, -152 removed lines

@@ -37,207 +37,207 @@
 
 class AnnotationReader implements MetadataReaderInterface
 {
-    /**
+/**
      * @var AnnotationManager
      */
-    protected $xManager;
+protected $xManager;
 
-    /**
+/**
      * @var Metadata
      */
-    protected $xMetadata;
+protected $xMetadata;
 
-    /**
+/**
      * Properties types, read from the "var" annotations.
      *
      * @var array
      */
-    protected $aPropTypes;
+protected $aPropTypes;
 
-    /**
+/**
      * The type of the class member being currently processed.
      *
      * @var string
      */
-    protected $sCurrMemberType;
+protected $sCurrMemberType;
 
-    /**
+/**
      * The constructor
      *
      * @param AnnotationManager $xManager
      */
-    public function __construct(AnnotationManager $xManager)
-    {
-        $this->xManager = $xManager;
-        $this->xManager->registry['upload'] = UploadAnnotation::class;
-        $this->xManager->registry['databag'] = DatabagAnnotation::class;
-        $this->xManager->registry['exclude'] = ExcludeAnnotation::class;
-        $this->xManager->registry['export'] = ExportAnnotation::class;
-        $this->xManager->registry['before'] = BeforeAnnotation::class;
-        $this->xManager->registry['after'] = AfterAnnotation::class;
-        $this->xManager->registry['di'] = ContainerAnnotation::class;
-        $this->xManager->registry['callback'] = CallbackAnnotation::class;
-        // Missing standard annotations.
-        // We need to define this, otherwise they throw an exception, and make the whole processing fail.
-        $this->xManager->registry['const'] = false;
-        $this->xManager->registry['inheritDoc'] = false;
-        $this->xManager->registry['template'] = false;
-        $this->xManager->registry['param-closure-this'] = false;
-    }
+public function __construct(AnnotationManager $xManager)
+{
+$this->xManager = $xManager;
+$this->xManager->registry['upload'] = UploadAnnotation::class;
+$this->xManager->registry['databag'] = DatabagAnnotation::class;
+$this->xManager->registry['exclude'] = ExcludeAnnotation::class;
+$this->xManager->registry['export'] = ExportAnnotation::class;
+$this->xManager->registry['before'] = BeforeAnnotation::class;
+$this->xManager->registry['after'] = AfterAnnotation::class;
+$this->xManager->registry['di'] = ContainerAnnotation::class;
+$this->xManager->registry['callback'] = CallbackAnnotation::class;
+// Missing standard annotations.
+// We need to define this, otherwise they throw an exception, and make the whole processing fail.
+$this->xManager->registry['const'] = false;
+$this->xManager->registry['inheritDoc'] = false;
+$this->xManager->registry['template'] = false;
+$this->xManager->registry['param-closure-this'] = false;
+}
 
-    /**
+/**
      * @return array
      */
-    public function getPropTypes(): array
-    {
-        return $this->aPropTypes;
-    }
+public function getPropTypes(): array
+{
+return $this->aPropTypes;
+}
 
-    /**
+/**
      * @return bool
      */
-    public function annotationIsOnProperty(): bool
-    {
-        return $this->sCurrMemberType === AnnotationManager::MEMBER_PROPERTY;
-    }
+public function annotationIsOnProperty(): bool
+{
+return $this->sCurrMemberType === AnnotationManager::MEMBER_PROPERTY;
+}
 
-    /**
+/**
      * @param string $sClass
      *
      * @return void
      * @throws AnnotationException
      */
-    private function readClassAnnotations(string $sClass): void
-    {
-        // Only keep the annotations declared in this package.
-        /** @var array<AbstractAnnotation> */
-        $aAnnotations = array_filter(
-            $this->xManager->getClassAnnotations($sClass),
-            fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
-        );
-        // First check if the class is excluded.
-        foreach($aAnnotations as $xAnnotation)
-        {
-            if(is_a($xAnnotation, ExcludeAnnotation::class))
-            {
-                $xAnnotation->saveValue($this->xMetadata);
-            }
-        }
-        if($this->xMetadata->isExcluded())
-        {
-            return;
-        }
-
-        foreach($aAnnotations as $xAnnotation)
-        {
-            if(!is_a($xAnnotation, ExcludeAnnotation::class))
-            {
-                $xAnnotation->saveValue($this->xMetadata);
-            }
-        }
-    }
+private function readClassAnnotations(string $sClass): void
+{
+// Only keep the annotations declared in this package.
+/** @var array<AbstractAnnotation> */
+$aAnnotations = array_filter(
+$this->xManager->getClassAnnotations($sClass),
+fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
+);
+// First check if the class is excluded.
+foreach($aAnnotations as $xAnnotation)
+{
+if(is_a($xAnnotation, ExcludeAnnotation::class))
+{
+    $xAnnotation->saveValue($this->xMetadata);
+}
+}
+if($this->xMetadata->isExcluded())
+{
+return;
+}
 
-    /**
+foreach($aAnnotations as $xAnnotation)
+{
+if(!is_a($xAnnotation, ExcludeAnnotation::class))
+{
+    $xAnnotation->saveValue($this->xMetadata);
+}
+}
+}
+
+/**
      * @param string $sClass
      * @param string $sProperty
      *
      * @return void
      * @throws AnnotationException
      */
-    private function readPropertyAnnotations(string $sClass, string $sProperty): void
+private function readPropertyAnnotations(string $sClass, string $sProperty): void
+{
+/** @var array<ContainerAnnotation> */
+// Only keep the annotations declared in this package.
+$aAnnotations = array_filter(
+$this->xManager->getPropertyAnnotations($sClass, $sProperty),
+function($xAnnotation) use($sProperty) {
+    // Save the property type
+    if(is_a($xAnnotation, VarAnnotation::class))
     {
-        /** @var array<ContainerAnnotation> */
-        // Only keep the annotations declared in this package.
-        $aAnnotations = array_filter(
-            $this->xManager->getPropertyAnnotations($sClass, $sProperty),
-            function($xAnnotation) use($sProperty) {
-                // Save the property type
-                if(is_a($xAnnotation, VarAnnotation::class))
-                {
-                    $this->aPropTypes[$sProperty] = $xAnnotation->type;
-                }
-                // Only container annotations are allowed on properties
-                return is_a($xAnnotation, ContainerAnnotation::class);
-            }
-        );
-        if(count($aAnnotations) > 1)
-        {
-            throw new AnnotationException('Only one @di annotation is allowed on a property');
-        }
-
-        foreach($aAnnotations as $xAnnotation)
-        {
-            $xAnnotation->setAttr($sProperty);
-            $xAnnotation->saveValue($this->xMetadata);
-        }
+        $this->aPropTypes[$sProperty] = $xAnnotation->type;
     }
+    // Only container annotations are allowed on properties
+    return is_a($xAnnotation, ContainerAnnotation::class);
+}
+);
+if(count($aAnnotations) > 1)
+{
+throw new AnnotationException('Only one @di annotation is allowed on a property');
+}
+
+foreach($aAnnotations as $xAnnotation)
+{
+$xAnnotation->setAttr($sProperty);
+$xAnnotation->saveValue($this->xMetadata);
+}
+}
 
-    /**
+/**
      * @param string $sClass
      * @param string $sMethod
      *
      * @return void
      * @throws AnnotationException
      */
-    private function readMethodAnnotations(string $sClass, string $sMethod): void
-    {
-        // Only keep the annotations declared in this package.
-        /** @var array<AbstractAnnotation> */
-        $aAnnotations = array_filter(
-            $this->xManager->getMethodAnnotations($sClass, $sMethod),
-            fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
-        );
-        foreach($aAnnotations as $xAnnotation)
-        {
-            $xAnnotation->saveValue($this->xMetadata, $sMethod);
-        }
-    }
+private function readMethodAnnotations(string $sClass, string $sMethod): void
+{
+// Only keep the annotations declared in this package.
+/** @var array<AbstractAnnotation> */
+$aAnnotations = array_filter(
+$this->xManager->getMethodAnnotations($sClass, $sMethod),
+fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
+);
+foreach($aAnnotations as $xAnnotation)
+{
+$xAnnotation->saveValue($this->xMetadata, $sMethod);
+}
+}
 
-    /**
+/**
      * @throws SetupException
      */
-    public function getAttributes(InputData $xInput): Metadata
-    {
-        ContainerAnnotation::$xReader = $this;
-        $this->aPropTypes = [];
-        $this->xMetadata = new Metadata();
-        $sClass = $xInput->getReflectionClass()->getName();
-
-        try
-        {
-            // Processing class annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_CLASS;
-
-            $this->readClassAnnotations($sClass);
-
-            // Processing properties annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_PROPERTY;
-
-            // Properties annotations
-            foreach($xInput->getProperties() as $sProperty)
-            {
-                $this->readPropertyAnnotations($sClass, $sProperty);
-            }
-
-            // The methods annotations are not taken for excluded classes.
-            if($this->xMetadata->isExcluded())
-            {
-                return $this->xMetadata;
-            }
-
-            // Processing methods annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_METHOD;
-
-            foreach($xInput->getMethods() as $sMethod)
-            {
-                $this->readMethodAnnotations($sClass, $sMethod);
-            }
-
-            return $this->xMetadata;
-        }
-        catch(AnnotationException $e)
-        {
-            throw new SetupException($e->getMessage());
-        }
-    }
+public function getAttributes(InputData $xInput): Metadata
+{
+ContainerAnnotation::$xReader = $this;
+$this->aPropTypes = [];
+$this->xMetadata = new Metadata();
+$sClass = $xInput->getReflectionClass()->getName();
+
+try
+{
+// Processing class annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_CLASS;
+
+$this->readClassAnnotations($sClass);
+
+// Processing properties annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_PROPERTY;
+
+// Properties annotations
+foreach($xInput->getProperties() as $sProperty)
+{
+    $this->readPropertyAnnotations($sClass, $sProperty);
+}
+
+// The methods annotations are not taken for excluded classes.
+if($this->xMetadata->isExcluded())
+{
+    return $this->xMetadata;
+}
+
+// Processing methods annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_METHOD;
+
+foreach($xInput->getMethods() as $sMethod)
+{
+    $this->readMethodAnnotations($sClass, $sMethod);
+}
+
+return $this->xMetadata;
+}
+catch(AnnotationException $e)
+{
+throw new SetupException($e->getMessage());
+}
+}
 }

jaxon-core/src/Di/Traits/ComponentTrait.php

Switch Indentation +59 added lines, -59 removed lines

@@ -241,83 +241,83 @@
                 $this->aComponentPublicMethods['node'],
             $xReflectionClass->isSubclassOf(FuncComponent::class) =>
                 $this->aComponentPublicMethods['func'],
-            default => [[], []],
-        };
+default => [[], []],
+};
 
-        return [$aMethods, ...$aBaseMethods];
-    }
+return [$aMethods, ...$aBaseMethods];
+}
 
-    /**
+/**
      * @param ReflectionClass $xReflectionClass
      * @param array $aMethods
      * @param array $aOptions
      *
      * @return Metadata|null
      */
-    private function getComponentMetadata(ReflectionClass $xReflectionClass,
-        array $aMethods, array $aOptions): Metadata|null
-    {
-        /** @var Config|null */
-        $xPackageConfig = $aOptions['config'] ?? null;
-        if($xPackageConfig === null || (bool)($aOptions['excluded'] ?? false))
-        {
-            return null;
-        }
-        $sMetadataFormat = $xPackageConfig->getOption('metadata.format');
-        if(!in_array($sMetadataFormat, ['attributes', 'annotations']))
-        {
-            return null;
-        }
+private function getComponentMetadata(ReflectionClass $xReflectionClass,
+array $aMethods, array $aOptions): Metadata|null
+{
+/** @var Config|null */
+$xPackageConfig = $aOptions['config'] ?? null;
+if($xPackageConfig === null || (bool)($aOptions['excluded'] ?? false))
+{
+return null;
+}
+$sMetadataFormat = $xPackageConfig->getOption('metadata.format');
+if(!in_array($sMetadataFormat, ['attributes', 'annotations']))
+{
+return null;
+}
 
-        // Try to get the class metadata from the cache.
-        $di = $this->cn();
-        $xMetadata = null;
-        $xMetadataCache = null;
-        $xConfig = $di->config();
-        if($xConfig->getAppOption('metadata.cache.enabled', false))
-        {
-            if(!$di->h('jaxon_metadata_cache_dir'))
-            {
-                $sCacheDir = $xConfig->getAppOption('metadata.cache.dir');
-                $di->val('jaxon_metadata_cache_dir', $sCacheDir);
-            }
-            $xMetadataCache = $di->getMetadataCache();
-            $xMetadata = $xMetadataCache->read($xReflectionClass->getName());
-            if($xMetadata !== null)
-            {
-                return $xMetadata;
-            }
-        }
+// Try to get the class metadata from the cache.
+$di = $this->cn();
+$xMetadata = null;
+$xMetadataCache = null;
+$xConfig = $di->config();
+if($xConfig->getAppOption('metadata.cache.enabled', false))
+{
+if(!$di->h('jaxon_metadata_cache_dir'))
+{
+    $sCacheDir = $xConfig->getAppOption('metadata.cache.dir');
+    $di->val('jaxon_metadata_cache_dir', $sCacheDir);
+}
+$xMetadataCache = $di->getMetadataCache();
+$xMetadata = $xMetadataCache->read($xReflectionClass->getName());
+if($xMetadata !== null)
+{
+    return $xMetadata;
+}
+}
 
-        $aProperties = array_map(fn($xProperty) => $xProperty->getName(),
-            $xReflectionClass->getProperties(ReflectionProperty::IS_PUBLIC |
-                ReflectionProperty::IS_PROTECTED));
+$aProperties = array_map(fn($xProperty) => $xProperty->getName(),
+$xReflectionClass->getProperties(ReflectionProperty::IS_PUBLIC |
+    ReflectionProperty::IS_PROTECTED));
 
-        $xMetadataReader = $di->getMetadataReader($sMetadataFormat);
-        $xInput = new InputData($xReflectionClass, $aMethods, $aProperties);
-        $xMetadata = $xMetadataReader->getAttributes($xInput);
+$xMetadataReader = $di->getMetadataReader($sMetadataFormat);
+$xInput = new InputData($xReflectionClass, $aMethods, $aProperties);
+$xMetadata = $xMetadataReader->getAttributes($xInput);
 
-        // Try to save the metadata in the cache
-        if($xMetadataCache !== null)
-        {
-            $xMetadataCache->save($xReflectionClass->getName(), $xMetadata);
-        }
+// Try to save the metadata in the cache
+if($xMetadataCache !== null)
+{
+$xMetadataCache->save($xReflectionClass->getName(), $xMetadata);
+}
 
-        return $xMetadata;
-    }
+return $xMetadata;
+}
 
-    /**
+/**
      * @param ReflectionClass $xReflectionClass
      * @param array $aOptions
      *
      * @return ComponentOptions
      */
-    public function getComponentOptions(ReflectionClass $xReflectionClass,
-        array $aOptions): ComponentOptions
-    {
-        $aMethods = $this->getPublicMethods($xReflectionClass);
-        $xMetadata = $this->getComponentMetadata($xReflectionClass, $aMethods[0], $aOptions);
+public function getComponentOptions(ReflectionClass $xReflectionClass,
+array $aOptions): ComponentOptions
+{
+$aMethods = $this->getPublicMethods($xReflectionClass);
+$xMetadata = $this->getComponentMetadata($xReflectionClass, $aMethods[0], $aOptions);
 
-        return new ComponentOptions($aMethods, $aOptions, $xMetadata);
-    }
+return new ComponentOptions($aMethods, $aOptions, $xMetadata);
+}
 }

jaxon-core/src/Di/Traits/PluginTrait.php

Switch Indentation +139 added lines, -139 removed lines

@@ -35,154 +35,154 @@ 
 
 trait PluginTrait
 {
-    /**
+/**
      * Register the values into the container
      *
      * @return void
      */
-    private function registerPlugins(): void
-    {
-        // Plugin manager
-        $this->set(PluginManager::class, function($di) {
-            $xPluginManager = new PluginManager($di->g(Container::class),
-                $di->g(CodeGenerator::class), $di->g(Translator::class));
-            // Register the Jaxon request and response plugins
-            $xPluginManager->registerPlugins();
-            return $xPluginManager;
-        });
-        // Package manager
-        $this->set(PackageManager::class, function($di) {
-            return new PackageManager($di->g(Container::class), $di->g(Translator::class),
-                $di->g(PluginManager::class), $di->g(ConfigManager::class),
-                $di->g(CodeGenerator::class), $di->g(ViewRenderer::class),
-                $di->g(CallbackManager::class), $di->g(ComponentRegistry::class));
-        });
-        // Code Generation
-        $this->set(MinifierInterface::class, function() {
-            return new class extends FileMinifier implements MinifierInterface
-            {};
-        });
-        $this->set(AssetManager::class, function($di) {
-            return new AssetManager($di->g(ConfigManager::class),
-                $di->g(MinifierInterface::class));
-        });
-        $this->set(CodeGenerator::class, function($di) {
-            return new CodeGenerator(Jaxon::VERSION, $di->g(Container::class),
-                $di->g(TemplateEngine::class));
-        });
-        $this->set(ConfigScriptGenerator::class, function($di) {
-            return new ConfigScriptGenerator($di->g(ParameterReader::class),
-                $di->g(TemplateEngine::class), $di->g(ConfigManager::class));
-        });
-        $this->set(ReadyScriptGenerator::class, function($di) {
-            return new ReadyScriptGenerator();
-        });
-
-        // Script response plugin
-        $this->set(ScriptPlugin::class, function($di) {
-            return new ScriptPlugin($di->g(CallFactory::class));
-        });
-        // Databag response plugin
-        $this->set(DatabagPlugin::class, function($di) {
-            return new DatabagPlugin($di->g(Container::class));
-        });
-        // Dialog response plugin
-        $this->set(DialogPlugin::class, function($di) {
-            return new DialogPlugin($di->g(DialogCommand::class));
-        });
-        // Paginator response plugin
-        $this->set(PaginatorPlugin::class, function($di) {
-            return new PaginatorPlugin($di->g(RendererInterface::class));
-        });
-    }
-
-    /**
+private function registerPlugins(): void
+{
+// Plugin manager
+$this->set(PluginManager::class, function($di) {
+$xPluginManager = new PluginManager($di->g(Container::class),
+    $di->g(CodeGenerator::class), $di->g(Translator::class));
+// Register the Jaxon request and response plugins
+$xPluginManager->registerPlugins();
+return $xPluginManager;
+});
+// Package manager
+$this->set(PackageManager::class, function($di) {
+return new PackageManager($di->g(Container::class), $di->g(Translator::class),
+    $di->g(PluginManager::class), $di->g(ConfigManager::class),
+    $di->g(CodeGenerator::class), $di->g(ViewRenderer::class),
+    $di->g(CallbackManager::class), $di->g(ComponentRegistry::class));
+});
+// Code Generation
+$this->set(MinifierInterface::class, function() {
+return new class extends FileMinifier implements MinifierInterface
+{};
+});
+$this->set(AssetManager::class, function($di) {
+return new AssetManager($di->g(ConfigManager::class),
+    $di->g(MinifierInterface::class));
+});
+$this->set(CodeGenerator::class, function($di) {
+return new CodeGenerator(Jaxon::VERSION, $di->g(Container::class),
+    $di->g(TemplateEngine::class));
+});
+$this->set(ConfigScriptGenerator::class, function($di) {
+return new ConfigScriptGenerator($di->g(ParameterReader::class),
+    $di->g(TemplateEngine::class), $di->g(ConfigManager::class));
+});
+$this->set(ReadyScriptGenerator::class, function($di) {
+return new ReadyScriptGenerator();
+});
+
+// Script response plugin
+$this->set(ScriptPlugin::class, function($di) {
+return new ScriptPlugin($di->g(CallFactory::class));
+});
+// Databag response plugin
+$this->set(DatabagPlugin::class, function($di) {
+return new DatabagPlugin($di->g(Container::class));
+});
+// Dialog response plugin
+$this->set(DialogPlugin::class, function($di) {
+return new DialogPlugin($di->g(DialogCommand::class));
+});
+// Paginator response plugin
+$this->set(PaginatorPlugin::class, function($di) {
+return new PaginatorPlugin($di->g(RendererInterface::class));
+});
+}
+
+/**
      * Get the plugin manager
      *
      * @return PluginManager
      */
-    public function getPluginManager(): PluginManager
-    {
-        return $this->g(PluginManager::class);
-    }
+public function getPluginManager(): PluginManager
+{
+return $this->g(PluginManager::class);
+}
 
-    /**
+/**
      * Get the package manager
      *
      * @return PackageManager
      */
-    public function getPackageManager(): PackageManager
-    {
-        return $this->g(PackageManager::class);
-    }
+public function getPackageManager(): PackageManager
+{
+return $this->g(PackageManager::class);
+}
 
-    /**
+/**
      * Get the code generator
      *
      * @return CodeGenerator
      */
-    public function getCodeGenerator(): CodeGenerator
-    {
-        return $this->g(CodeGenerator::class);
-    }
+public function getCodeGenerator(): CodeGenerator
+{
+return $this->g(CodeGenerator::class);
+}
 
-    /**
+/**
      * Get the asset manager
      *
      * @return AssetManager
      */
-    public function getAssetManager(): AssetManager
-    {
-        return $this->g(AssetManager::class);
-    }
+public function getAssetManager(): AssetManager
+{
+return $this->g(AssetManager::class);
+}
 
-    /**
+/**
      * Get the jQuery plugin
      *
      * @return ScriptPlugin
      */
-    public function getScriptPlugin(): ScriptPlugin
-    {
-        return $this->g(ScriptPlugin::class);
-    }
+public function getScriptPlugin(): ScriptPlugin
+{
+return $this->g(ScriptPlugin::class);
+}
 
-    /**
+/**
      * Get the dialog plugin
      *
      * @return DialogPlugin
      */
-    public function getDialogPlugin(): DialogPlugin
-    {
-        return $this->g(DialogPlugin::class);
-    }
+public function getDialogPlugin(): DialogPlugin
+{
+return $this->g(DialogPlugin::class);
+}
 
-    /**
+/**
      * @param class-string $sClassName    The package class name
      *
      * @return string
      */
-    private function getPackageConfigKey(string $sClassName): string
-    {
-        return $sClassName . '_PackageConfig';
-    }
+private function getPackageConfigKey(string $sClassName): string
+{
+return $sClassName . '_PackageConfig';
+}
 
-    /**
+/**
      * @param class-string $sClassName    The package class name
      * @param-closure-this AbstractPackage $cSetter
      *
      * @return void
      */
-    private function extendPackage(string $sClassName, Closure $cSetter): void
-    {
-        // Initialize the package instance.
-        $this->xLibContainer->extend($sClassName, function($xPackage) use($cSetter) {
-            // Allow the setter to access protected attributes.
-            call_user_func($cSetter->bindTo($xPackage, $xPackage));
-            return $xPackage;
-        });
-    }
-
-    /**
+private function extendPackage(string $sClassName, Closure $cSetter): void
+{
+// Initialize the package instance.
+$this->xLibContainer->extend($sClassName, function($xPackage) use($cSetter) {
+// Allow the setter to access protected attributes.
+call_user_func($cSetter->bindTo($xPackage, $xPackage));
+return $xPackage;
+});
+}
+
+/**
      * Register a package
      *
      * @param class-string $sClassName    The package class name
@@ -191,45 +191,45 @@ 
      * @return void
      * @throws SetupException
      */
-    public function registerPackage(string $sClassName, array $aUserOptions): void
-    {
-        // Register the user class, but only if the user didn't already.
-        if(!$this->h($sClassName))
-        {
-            $this->set($sClassName, fn() => $this->make($sClassName));
-        }
-
-        // Save the package config in the container.
-        $sConfigKey = $this->getPackageConfigKey($sClassName);
-        $this->set($sConfigKey, function($di) use($aUserOptions) {
-            $xOptionsProvider = $aUserOptions['provider'] ?? null;
-            // The user can provide a callable that returns the package options.
-            if(is_callable($xOptionsProvider))
-            {
-                $aUserOptions = $xOptionsProvider($aUserOptions);
-            }
-            return $di->g(ConfigManager::class)->newConfig($aUserOptions);
-        });
-
-        // Initialize the package instance.
-        $di = $this;
-        $this->extendPackage($sClassName, function() use($di, $sConfigKey) {
-            // $this here refers to the AbstractPackage instance.
-            $this->xPkgConfig = $di->g($sConfigKey);
-            $this->xRenderer = $di->g(ViewRenderer::class);
-            $this->init();
-        });
-    }
-
-    /**
+public function registerPackage(string $sClassName, array $aUserOptions): void
+{
+// Register the user class, but only if the user didn't already.
+if(!$this->h($sClassName))
+{
+$this->set($sClassName, fn() => $this->make($sClassName));
+}
+
+// Save the package config in the container.
+$sConfigKey = $this->getPackageConfigKey($sClassName);
+$this->set($sConfigKey, function($di) use($aUserOptions) {
+$xOptionsProvider = $aUserOptions['provider'] ?? null;
+// The user can provide a callable that returns the package options.
+if(is_callable($xOptionsProvider))
+{
+    $aUserOptions = $xOptionsProvider($aUserOptions);
+}
+return $di->g(ConfigManager::class)->newConfig($aUserOptions);
+});
+
+// Initialize the package instance.
+$di = $this;
+$this->extendPackage($sClassName, function() use($di, $sConfigKey) {
+// $this here refers to the AbstractPackage instance.
+$this->xPkgConfig = $di->g($sConfigKey);
+$this->xRenderer = $di->g(ViewRenderer::class);
+$this->init();
+});
+}
+
+/**
      * Get the config of a package
      *
      * @param class-string $sClassName    The package class name
      *
      * @return Config
      */
-    public function getPackageConfig(string $sClassName): Config
-    {
-        return $this->g($this->getPackageConfigKey($sClassName));
-    }
+public function getPackageConfig(string $sClassName): Config
+{
+return $this->g($this->getPackageConfigKey($sClassName));
+}
 }