diff --git a/README.md b/README.md
index 25cba12..69ab7bc 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ ValueTask<bool> CanLeaveAsync() => { ... ask the user };
 
 There is an embedded **leak-detector** to help you identify memory leaks in your application.
 
-Find out more at [Nalu Website](https://nalu-development.github.io/nalu/).
+**Find out more at [Nalu Website](https://nalu-development.github.io/nalu/).**
 
 ### Layouts [![Nalu.Maui.Layouts NuGet Package](https://img.shields.io/nuget/v/Nalu.Maui.Layouts.svg)](https://www.nuget.org/packages/Nalu.Maui.Layouts/) [![Nalu.Maui NuGet Package Downloads](https://img.shields.io/nuget/dt/Nalu.Maui.Layouts)](https://www.nuget.org/packages/Nalu.Maui.Layouts/)
 
@@ -46,21 +46,21 @@ Cross-platform layouts and utilities for MAUI applications simplify dealing with
 
 - Have you ever dreamed of having an `if` statement in XAML?
   ```csharp
-    <layouts:ConditionedTemplate Value="{Binding HasPermission}"
-                                 TrueTemplate="{StaticResource AdminFormTemplate}"
-                                 FalseTemplate="{StaticResource PermissionRequestTemplate}" />
+    <nalu:ToggleTemplate Value="{Binding HasPermission}"
+                         WhenTrue="{StaticResource AdminFormTemplate}"
+                         WhenFalse="{StaticResource PermissionRequestTemplate}" />
   ```
 - Do you want to scope the binding context of a content?
   ```csharp
-    <layouts:Component ContentBindingContext="{Binding SelectedAnimal}"
-                       IsVisible="{Binding IsSelected}">
+    <nalu:ViewBox ContentBindingContext="{Binding SelectedAnimal}"
+                  IsVisible="{Binding IsSelected}">
         <views:AnimalView x:DataType="models:Animal" />
-    </layouts:Component>
+    </nalu:ViewBox>
   ```
 - And what about rendering a `TemplateSelector` directly like we do on a `CollectionView`?
   ```csharp
-    <layouts:TemplatedComponent ContentTemplateSelector="{StaticResource AnimalTemplateSelector}"
-                                ContentBindingContext="{Binding CurrentAnimal}" />
+    <nalu:TemplateBox ContentTemplateSelector="{StaticResource AnimalTemplateSelector}"
+                      ContentBindingContext="{Binding CurrentAnimal}" />
   ```
 
-Find out more at [Nalu Website](https://nalu-development.github.io/nalu/).
+**Find out more at [Nalu Website](https://nalu-development.github.io/nalu/).**
diff --git a/Samples/Nalu.Maui.Sample/Pages/FivePage.xaml b/Samples/Nalu.Maui.Sample/Pages/FivePage.xaml
index f28bf00..a56cbd9 100644
--- a/Samples/Nalu.Maui.Sample/Pages/FivePage.xaml
+++ b/Samples/Nalu.Maui.Sample/Pages/FivePage.xaml
@@ -20,36 +20,36 @@
                 </Label.FormattedText>
             </Label>
             <Button Text="Navigate to /One/Three" Command="{Binding GoToThreeCommand}" />
-            <nalu:ConditionedTemplate Value="True" ContentBindingContext="A true statement">
-                <nalu:ConditionedTemplate.TrueTemplate>
+            <nalu:ToggleTemplate Value="True" ContentBindingContext="A true statement">
+                <nalu:ToggleTemplate.WhenTrue>
                     <DataTemplate x:DataType="x:String">
                         <Label Text="{Binding .}" />
                     </DataTemplate>
-                </nalu:ConditionedTemplate.TrueTemplate>
-                <nalu:ConditionedTemplate.FalseTemplate>
+                </nalu:ToggleTemplate.WhenTrue>
+                <nalu:ToggleTemplate.WhenFalse>
                     <DataTemplate>
                         <Label Text="This is false" />
                     </DataTemplate>
-                </nalu:ConditionedTemplate.FalseTemplate>
-            </nalu:ConditionedTemplate>
+                </nalu:ToggleTemplate.WhenFalse>
+            </nalu:ToggleTemplate>
             <Border BindingContext="Hello world"
                     BackgroundColor="LightBlue"
                     StrokeShape="RoundRectangle 24">
-                <nalu:Component Padding="16,8" x:DataType="x:String">
+                <nalu:ViewBox Padding="16,8" x:DataType="x:String">
                     <Label Text="{Binding .}"/>
-                </nalu:Component>
+                </nalu:ViewBox>
             </Border>
-            <nalu:TemplatedComponent>
-                <nalu:TemplatedComponent.ContentTemplate>
+            <nalu:TemplateBox>
+                <nalu:TemplateBox.ContentTemplate>
                     <DataTemplate>
                         <HorizontalStackLayout>
                             <Label Text="Projected => " />
-                            <nalu:ProjectContainer />
+                            <nalu:TemplateContentPresenter />
                         </HorizontalStackLayout>
                     </DataTemplate>
-                </nalu:TemplatedComponent.ContentTemplate>
+                </nalu:TemplateBox.ContentTemplate>
                 <Label Text="I'm here!" />
-            </nalu:TemplatedComponent>
+            </nalu:TemplateBox>
         </VerticalStackLayout>
     </ContentPage.Content>
 </ContentPage>
diff --git a/Samples/Nalu.Maui.Sample/Pages/OnePage.xaml b/Samples/Nalu.Maui.Sample/Pages/OnePage.xaml
index 59bb111..8441e78 100644
--- a/Samples/Nalu.Maui.Sample/Pages/OnePage.xaml
+++ b/Samples/Nalu.Maui.Sample/Pages/OnePage.xaml
@@ -26,9 +26,9 @@
                 </Label.FormattedText>
             </Label>
 
-            <layouts:Component ContentBindingContext="{Binding Animal}">
+            <layouts:ViewBox ContentBindingContext="{Binding Animal}">
                 <Label Text="{Binding Name}" x:DataType="pageModels:AnimalModel" />
-            </layouts:Component>
+            </layouts:ViewBox>
 
             <Button Command="{Binding PushThreeCommand}"
                     Text="Push Three"
diff --git a/Source/Nalu.Maui.Layouts/Layouts/ConditionedTemplate.cs b/Source/Nalu.Maui.Layouts/Layouts/ConditionedTemplate.cs
deleted file mode 100644
index 7202d07..0000000
--- a/Source/Nalu.Maui.Layouts/Layouts/ConditionedTemplate.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-namespace Nalu;
-
-/// <summary>
-/// A <see cref="Component"/> that uses a <see cref="DataTemplate"/> to render content based on a boolean value.
-/// </summary>
-public class ConditionedTemplate : TemplatedComponentBase
-{
-    /// <summary>
-    /// Bindable property for <see cref="TrueTemplate"/> property.
-    /// </summary>
-    public static readonly BindableProperty TrueTemplateProperty =
-        BindableProperty.Create(nameof(TrueTemplate), typeof(DataTemplate), typeof(ConditionedTemplate), propertyChanged: ConditionChanged);
-
-    /// <summary>
-    /// Bindable property for <see cref="FalseTemplate"/> property.
-    /// </summary>
-    public static readonly BindableProperty FalseTemplateProperty =
-        BindableProperty.Create(nameof(FalseTemplate), typeof(DataTemplate), typeof(ConditionedTemplate), propertyChanged: ConditionChanged);
-
-    /// <summary>
-    /// Bindable property for <see cref="Value"/> property.
-    /// </summary>
-    public static readonly BindableProperty ValueProperty = BindableProperty.Create(nameof(Value), typeof(bool?), typeof(ConditionedTemplate), propertyChanged: ConditionChanged);
-
-    /// <summary>
-    /// Gets or sets the <see cref="DataTemplate"/> to use when the value is false.
-    /// </summary>
-    public DataTemplate FalseTemplate
-    {
-        get => (DataTemplate)GetValue(FalseTemplateProperty);
-        set => SetValue(FalseTemplateProperty, value);
-    }
-
-    /// <summary>
-    /// Gets or sets the <see cref="DataTemplate"/> to use when the value is true.
-    /// </summary>
-    public DataTemplate TrueTemplate
-    {
-        get => (DataTemplate)GetValue(TrueTemplateProperty);
-        set => SetValue(TrueTemplateProperty, value);
-    }
-
-    /// <summary>
-    /// Gets or sets the value to determine which template to use.
-    /// </summary>
-    public bool? Value
-    {
-        get => (bool?)GetValue(ValueProperty);
-        set => SetValue(ValueProperty, value);
-    }
-
-    private void SetTemplateFromValue()
-    {
-        var template = Value switch
-        {
-            true => TrueTemplate,
-            false => FalseTemplate,
-            _ => null,
-        };
-
-        SetTemplate(template);
-    }
-
-    private static void ConditionChanged(BindableObject bindable, object oldvalue, object newvalue)
-    {
-        if (bindable is ConditionedTemplate chooseTemplate)
-        {
-            chooseTemplate.SetTemplateFromValue();
-        }
-    }
-}
diff --git a/Source/Nalu.Maui.Layouts/Layouts/ProjectContainer.cs b/Source/Nalu.Maui.Layouts/Layouts/ProjectContainer.cs
deleted file mode 100644
index 850f664..0000000
--- a/Source/Nalu.Maui.Layouts/Layouts/ProjectContainer.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-namespace Nalu;
-
-/// <summary>
-/// A <see cref="Component"/> to display the <see cref="TemplatedComponentBase.ProjectedContent" />.
-/// </summary>
-public class ProjectContainer : Component
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ProjectContainer"/> class.
-    /// </summary>
-    public ProjectContainer()
-    {
-        var binding = new Binding(nameof(TemplatedComponent.ProjectedContent), source: new RelativeBindingSource(RelativeBindingSourceMode.FindAncestor, typeof(TemplatedComponentBase)));
-        SetBinding(ContentProperty, binding);
-    }
-}
diff --git a/Source/Nalu.Maui.Layouts/Layouts/TemplatedComponent.cs b/Source/Nalu.Maui.Layouts/Layouts/TemplateBox.cs
similarity index 72%
rename from Source/Nalu.Maui.Layouts/Layouts/TemplatedComponent.cs
rename to Source/Nalu.Maui.Layouts/Layouts/TemplateBox.cs
index c8c57c8..aceb9e3 100644
--- a/Source/Nalu.Maui.Layouts/Layouts/TemplatedComponent.cs
+++ b/Source/Nalu.Maui.Layouts/Layouts/TemplateBox.cs
@@ -1,9 +1,9 @@
 namespace Nalu;
 
 /// <summary>
-/// A <see cref="Component"/> that uses a <see cref="DataTemplate"/> to render content.
+/// A <see cref="ViewBox"/> that uses a <see cref="DataTemplate"/> or <see cref="DataTemplateSelector"/> to render content.
 /// </summary>
-public class TemplatedComponent : TemplatedComponentBase
+public class TemplateBox : TemplateBoxBase
 {
     /// <summary>
     /// Bindable property for <see cref="ContentTemplate"/> property.
@@ -11,7 +11,7 @@ public class TemplatedComponent : TemplatedComponentBase
     public static readonly BindableProperty ContentTemplateProperty = BindableProperty.Create(
         nameof(ContentTemplate),
         typeof(DataTemplate),
-        typeof(TemplatedComponent),
+        typeof(TemplateBox),
         propertyChanged: ContentTemplateChanged);
 
     /// <summary>
@@ -25,9 +25,9 @@ public DataTemplate? ContentTemplate
 
     private static void ContentTemplateChanged(BindableObject bindable, object? oldvalue, object? newvalue)
     {
-        if (bindable is TemplatedComponent templateLayout)
+        if (bindable is TemplateBox templateBox)
         {
-            templateLayout.SetTemplate(newvalue as DataTemplate);
+            templateBox.SetTemplate(newvalue as DataTemplate);
         }
     }
 }
diff --git a/Source/Nalu.Maui.Layouts/Layouts/TemplatedComponentBase.cs b/Source/Nalu.Maui.Layouts/Layouts/TemplateBoxBase.cs
similarity index 83%
rename from Source/Nalu.Maui.Layouts/Layouts/TemplatedComponentBase.cs
rename to Source/Nalu.Maui.Layouts/Layouts/TemplateBoxBase.cs
index 51a6627..bc38e07 100644
--- a/Source/Nalu.Maui.Layouts/Layouts/TemplatedComponentBase.cs
+++ b/Source/Nalu.Maui.Layouts/Layouts/TemplateBoxBase.cs
@@ -1,28 +1,28 @@
 namespace Nalu;
 
 /// <summary>
-/// A <see cref="Component"/> base class that uses a <see cref="DataTemplate"/> to render content.
+/// A <see cref="ViewBox"/> base class that uses a <see cref="DataTemplate"/> to render content.
 /// </summary>
-[ContentProperty(nameof(ProjectedContent))]
-public abstract class TemplatedComponentBase : ComponentBase
+[ContentProperty(nameof(TemplateContent))]
+public abstract class TemplateBoxBase : ViewBoxBase
 {
     /// <summary>
-    /// Bindable property for <see cref="ProjectedContent"/> property.
+    /// Bindable property for <see cref="TemplateContent"/> property.
     /// </summary>
-    public static readonly BindableProperty ProjectedContentProperty = BindableProperty.Create(
-        nameof(ProjectedContent),
+    public static readonly BindableProperty TemplateContentProperty = BindableProperty.Create(
+        nameof(TemplateContent),
         typeof(IView),
-        typeof(TemplatedComponent));
+        typeof(TemplateBox));
 
     private bool _changingTemplate;
 
     /// <summary>
-    /// Gets or sets the content to be projected through `ProjectContainer`.
+    /// Gets or sets the content to be projected through <see cref="TemplateContentPresenter"/> component.
     /// </summary>
-    public IView? ProjectedContent
+    public IView? TemplateContent
     {
-        get => (IView?)GetValue(ProjectedContentProperty);
-        set => SetValue(ProjectedContentProperty, value);
+        get => (IView?)GetValue(TemplateContentProperty);
+        set => SetValue(TemplateContentProperty, value);
     }
 
     /// <summary>
diff --git a/Source/Nalu.Maui.Layouts/Layouts/TemplateContentPresenter.cs b/Source/Nalu.Maui.Layouts/Layouts/TemplateContentPresenter.cs
new file mode 100644
index 0000000..48cf5ed
--- /dev/null
+++ b/Source/Nalu.Maui.Layouts/Layouts/TemplateContentPresenter.cs
@@ -0,0 +1,16 @@
+namespace Nalu;
+
+/// <summary>
+/// A <see cref="ViewBox"/> to display the <see cref="TemplateBoxBase.TemplateContent" />.
+/// </summary>
+public class TemplateContentPresenter : ViewBox
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TemplateContentPresenter"/> class.
+    /// </summary>
+    public TemplateContentPresenter()
+    {
+        var binding = new Binding(nameof(TemplateBox.TemplateContent), source: new RelativeBindingSource(RelativeBindingSourceMode.FindAncestor, typeof(TemplateBoxBase)));
+        SetBinding(ContentProperty, binding);
+    }
+}
diff --git a/Source/Nalu.Maui.Layouts/Layouts/ToggleTemplate.cs b/Source/Nalu.Maui.Layouts/Layouts/ToggleTemplate.cs
new file mode 100644
index 0000000..e934658
--- /dev/null
+++ b/Source/Nalu.Maui.Layouts/Layouts/ToggleTemplate.cs
@@ -0,0 +1,71 @@
+namespace Nalu;
+
+/// <summary>
+/// A <see cref="ViewBox"/> that uses a <see cref="DataTemplate"/> to render content based on a boolean value.
+/// </summary>
+public class ToggleTemplate : TemplateBoxBase
+{
+    /// <summary>
+    /// Bindable property for <see cref="WhenTrue"/> property.
+    /// </summary>
+    public static readonly BindableProperty WhenTrueProperty =
+        BindableProperty.Create(nameof(WhenTrue), typeof(DataTemplate), typeof(ToggleTemplate), propertyChanged: ConditionChanged);
+
+    /// <summary>
+    /// Bindable property for <see cref="WhenFalse"/> property.
+    /// </summary>
+    public static readonly BindableProperty WhenFalseProperty =
+        BindableProperty.Create(nameof(WhenFalse), typeof(DataTemplate), typeof(ToggleTemplate), propertyChanged: ConditionChanged);
+
+    /// <summary>
+    /// Bindable property for <see cref="Value"/> property.
+    /// </summary>
+    public static readonly BindableProperty ValueProperty = BindableProperty.Create(nameof(Value), typeof(bool?), typeof(ToggleTemplate), propertyChanged: ConditionChanged);
+
+    /// <summary>
+    /// Gets or sets the <see cref="DataTemplate"/> to use when the value is false.
+    /// </summary>
+    public DataTemplate? WhenFalse
+    {
+        get => (DataTemplate?)GetValue(WhenFalseProperty);
+        set => SetValue(WhenFalseProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the <see cref="DataTemplate"/> to use when the value is true.
+    /// </summary>
+    public DataTemplate? WhenTrue
+    {
+        get => (DataTemplate?)GetValue(WhenTrueProperty);
+        set => SetValue(WhenTrueProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the value to determine which template to use.
+    /// </summary>
+    public bool? Value
+    {
+        get => (bool?)GetValue(ValueProperty);
+        set => SetValue(ValueProperty, value);
+    }
+
+    private void SetTemplateFromValue()
+    {
+        var template = Value switch
+        {
+            true => WhenTrue,
+            false => WhenFalse,
+            _ => null,
+        };
+
+        SetTemplate(template);
+    }
+
+    private static void ConditionChanged(BindableObject bindable, object oldvalue, object newvalue)
+    {
+        if (bindable is ToggleTemplate toggleTemplate)
+        {
+            toggleTemplate.SetTemplateFromValue();
+        }
+    }
+}
diff --git a/Source/Nalu.Maui.Layouts/Layouts/Component.cs b/Source/Nalu.Maui.Layouts/Layouts/ViewBox.cs
similarity index 79%
rename from Source/Nalu.Maui.Layouts/Layouts/Component.cs
rename to Source/Nalu.Maui.Layouts/Layouts/ViewBox.cs
index e8ec57f..ff64a68 100644
--- a/Source/Nalu.Maui.Layouts/Layouts/Component.cs
+++ b/Source/Nalu.Maui.Layouts/Layouts/ViewBox.cs
@@ -7,12 +7,12 @@ namespace Nalu;
 /// Can be used as a replacement of <see cref="ContentView"/> (which as-of .NET 8 uses Compatibility.Layout).
 /// </remarks>
 [ContentProperty(nameof(Content))]
-public class Component : ComponentBase
+public class ViewBox : ViewBoxBase
 {
     /// <summary>
     /// Bindable property for <see cref="Content"/> property.
     /// </summary>
-    public static readonly BindableProperty ContentProperty = BindableProperty.Create(nameof(Content), typeof(IView), typeof(Component), propertyChanged: OnContentPropertyChanged);
+    public static readonly BindableProperty ContentProperty = BindableProperty.Create(nameof(Content), typeof(IView), typeof(ViewBox), propertyChanged: OnContentPropertyChanged);
 
     /// <summary>
     /// Gets or sets the content of the layout.
@@ -30,5 +30,5 @@ public IView? Content
     protected override void SetContent(IView? content) => SetValue(ContentProperty, content);
 
     private static void OnContentPropertyChanged(BindableObject bindable, object? oldValue, object? newValue)
-        => ((Component)bindable).OnContentPropertyChanged((IView?)oldValue, (IView?)newValue);
+        => ((ViewBox)bindable).OnContentPropertyChanged((IView?)oldValue, (IView?)newValue);
 }
diff --git a/Source/Nalu.Maui.Layouts/Layouts/ComponentBase.cs b/Source/Nalu.Maui.Layouts/Layouts/ViewBoxBase.cs
similarity index 88%
rename from Source/Nalu.Maui.Layouts/Layouts/ComponentBase.cs
rename to Source/Nalu.Maui.Layouts/Layouts/ViewBoxBase.cs
index 36eff78..9e91fd4 100644
--- a/Source/Nalu.Maui.Layouts/Layouts/ComponentBase.cs
+++ b/Source/Nalu.Maui.Layouts/Layouts/ViewBoxBase.cs
@@ -3,15 +3,12 @@ namespace Nalu;
 using Microsoft.Maui.Layouts;
 
 /// <summary>
-/// ContentLayoutBase is a base class for a layout that is used to display a single view.
+/// <see cref="ViewBoxBase"/> is a base class a <see cref="IContentView"/> that is used to display a single view.
 /// </summary>
-/// <remarks>
-/// Can be used as a replacement of <see cref="ContentView"/> (which as-of .NET 8 uses Compatibility.Layout).
-/// </remarks>
-public abstract class ComponentBase : View, IContentView
+public abstract class ViewBoxBase : View, IContentView
 {
     private ILayoutManager? _layoutManager;
-    private ILayoutManager LayoutManager => _layoutManager ??= new ComponentLayoutManager(this);
+    private ILayoutManager LayoutManager => _layoutManager ??= new ViewBoxLayoutManager(this);
 
     /// <summary>
     /// Bindable property for <see cref="Padding"/> property.
@@ -19,12 +16,12 @@ public abstract class ComponentBase : View, IContentView
     public static readonly BindableProperty PaddingProperty = BindableProperty.Create(
         nameof(Padding),
         typeof(Thickness),
-        typeof(ComponentBase),
+        typeof(ViewBoxBase),
         default(Thickness),
         propertyChanged: OnPaddingPropertyChanged);
 
     private static void OnPaddingPropertyChanged(BindableObject bindable, object oldvalue, object newvalue)
-        => ((ComponentBase)bindable).OnPaddingPropertyChanged((Thickness)oldvalue, (Thickness)newvalue);
+        => ((ViewBoxBase)bindable).OnPaddingPropertyChanged((Thickness)oldvalue, (Thickness)newvalue);
 
     /// <summary>
     /// Bindable property for <see cref="ContentBindingContext"/> property.
@@ -32,7 +29,7 @@ private static void OnPaddingPropertyChanged(BindableObject bindable, object old
     public static readonly BindableProperty ContentBindingContextProperty = BindableProperty.Create(
         nameof(ContentBindingContext),
         typeof(object),
-        typeof(Component),
+        typeof(ViewBox),
         propertyChanged: ContentBindingContextPropertyChanged);
 
     /// <summary>
@@ -157,9 +154,9 @@ protected virtual void SetContent(IView? content)
 
     private static void ContentBindingContextPropertyChanged(BindableObject bindable, object? oldvalue, object? newvalue)
     {
-        if (bindable is ComponentBase contentLayout)
+        if (bindable is ViewBoxBase viewBoxBase)
         {
-            contentLayout.ContentBindingContextPropertyChanged(oldvalue, newvalue);
+            viewBoxBase.ContentBindingContextPropertyChanged(oldvalue, newvalue);
         }
     }
 }
diff --git a/Source/Nalu.Maui.Layouts/Layouts/ComponentLayoutManager.cs b/Source/Nalu.Maui.Layouts/Layouts/ViewBoxLayoutManager.cs
similarity index 95%
rename from Source/Nalu.Maui.Layouts/Layouts/ComponentLayoutManager.cs
rename to Source/Nalu.Maui.Layouts/Layouts/ViewBoxLayoutManager.cs
index f002c0c..f50a324 100644
--- a/Source/Nalu.Maui.Layouts/Layouts/ComponentLayoutManager.cs
+++ b/Source/Nalu.Maui.Layouts/Layouts/ViewBoxLayoutManager.cs
@@ -3,10 +3,10 @@ namespace Nalu;
 using Microsoft.Maui.Layouts;
 
 /// <summary>
-/// Layout manager for <see cref="Component"/>.
+/// Layout manager for <see cref="ViewBox"/>.
 /// </summary>
 /// <param name="contentView">The layout using this <see cref="ILayoutManager"/>.</param>
-public class ComponentLayoutManager(IContentView contentView) : ILayoutManager
+public class ViewBoxLayoutManager(IContentView contentView) : ILayoutManager
 {
     /// <inheritdoc cref="ILayoutManager.Measure"/>
     public Size Measure(double widthConstraint, double heightConstraint)
diff --git a/Source/Nalu.Maui.Navigation/Interfaces/NavigationIntentBehavior.cs b/Source/Nalu.Maui.Navigation/Interfaces/NavigationIntentBehavior.cs
index 839e36b..dcfebab 100644
--- a/Source/Nalu.Maui.Navigation/Interfaces/NavigationIntentBehavior.cs
+++ b/Source/Nalu.Maui.Navigation/Interfaces/NavigationIntentBehavior.cs
@@ -6,26 +6,26 @@ namespace Nalu;
 public enum NavigationIntentBehavior
 {
     /// <summary>
-    /// When a navigation intent is detected, only intent-related navigation lifecycle events will be triggered.
+    /// When a navigation intent is detected, if the corresponding intent-related navigation lifecycle event is not defined, the navigation will default to the generic event.
     /// </summary>
     /// <example>
-    /// In the following example, if <c>MyIntent</c> is detected, the navigation will invoke only <c>OnAppearingAsync(MyIntent)</c>.
+    /// In the following example, if <c>MyIntent</c> is detected, the navigation will invoke <c>OnEnteringAsync</c> and <c>OnAppearingAsync(MyIntent)</c> in sequence.
     /// <code>
     /// public ValueTask OnEnteringAsync()
     /// public ValueTask OnAppearingAsync(MyIntent)
     /// </code>
     /// </example>
-    Strict,
+    Fallthrough,
 
     /// <summary>
-    /// When a navigation intent is detected, if the corresponding intent-related navigation lifecycle event is not defined, the navigation will fall through to the generic one.
+    /// When a navigation intent is detected, only intent-related navigation lifecycle events will be triggered.
     /// </summary>
     /// <example>
-    /// In the following example, if <c>MyIntent</c> is detected, the navigation will invoke <c>OnEnteringAsync</c> and <c>OnAppearingAsync(MyIntent)</c> in sequence.
+    /// In the following example, if <c>MyIntent</c> is detected, the navigation will only invoke <c>OnAppearingAsync(MyIntent)</c>.
     /// <code>
     /// public ValueTask OnEnteringAsync()
     /// public ValueTask OnAppearingAsync(MyIntent)
     /// </code>
     /// </example>
-    Fallthrough,
+    Strict,
 }
diff --git a/Tests/Nalu.Maui.Test/Layouts/TemplatedComponentTests.cs b/Tests/Nalu.Maui.Test/Layouts/TemplateBoxTests.cs
similarity index 91%
rename from Tests/Nalu.Maui.Test/Layouts/TemplatedComponentTests.cs
rename to Tests/Nalu.Maui.Test/Layouts/TemplateBoxTests.cs
index 63744af..9e9e6e9 100644
--- a/Tests/Nalu.Maui.Test/Layouts/TemplatedComponentTests.cs
+++ b/Tests/Nalu.Maui.Test/Layouts/TemplateBoxTests.cs
@@ -1,12 +1,12 @@
 namespace Nalu.Maui.Test.Layouts;
 
-public class TemplatedComponentTests
+public class TemplateBoxTests
 {
     [Fact(DisplayName = "ContentTemplate property should set and get content template")]
     public void ContentTemplateProperty_Should_SetAndGetContentTemplate()
     {
         // Arrange
-        var templatedComponent = new TemplatedComponent();
+        var templatedComponent = new TemplateBox();
         var dataTemplate = new DataTemplate(() => new Label { Text = "Test" });
 
         // Act
@@ -21,7 +21,7 @@ public void ContentTemplateProperty_Should_SetAndGetContentTemplate()
     public void ContentTemplatePropertyShouldUpdateContentAndContentTemplate()
     {
         // Arrange
-        var templatedComponent = new TemplatedComponent();
+        var templatedComponent = new TemplateBox();
         var oldDataTemplate = new DataTemplate(() => new Label { Text = "Old" });
         var newDataTemplate = new DataTemplate(() => new Label { Text = "New" });
 
@@ -39,7 +39,7 @@ public void ContentTemplatePropertyShouldUpdateContentAndContentTemplate()
     public void ContentTemplateAcceptsADataTemplateSelectorBasedOnBindingContext()
     {
         // Arrange
-        var templatedComponent = new TemplatedComponent();
+        var templatedComponent = new TemplateBox();
         var dataTemplateSelector = new TestTemplateSelector();
         var bindingContext = "hello";
         templatedComponent.BindingContext = bindingContext;
@@ -59,7 +59,7 @@ public void ContentTemplateAcceptsADataTemplateSelectorBasedOnBindingContext()
     public void ContentTemplateAcceptsADataTemplateSelectorBasedOnContentBindingContext()
     {
         // Arrange
-        var templatedComponent = new TemplatedComponent();
+        var templatedComponent = new TemplateBox();
         var dataTemplateSelector = new TestTemplateSelector();
         var bindingContext = "hello";
         var contentBindingContext = "world";
@@ -81,7 +81,7 @@ public void ContentTemplateAcceptsADataTemplateSelectorBasedOnContentBindingCont
     public void BindingContextSetThroughContentBindingContextShouldBeClearedFromContentOnRemoval()
     {
         // Arrange
-        var component = new TemplatedComponent();
+        var component = new TemplateBox();
         var newBindingContext = new object();
         component.ContentBindingContext = newBindingContext;
         component.ContentTemplate = new DataTemplate(() => new Label());
@@ -99,7 +99,7 @@ public void BindingContextSetThroughContentBindingContextShouldBeClearedFromCont
     public void BindingContextSetThroughBindingContextShouldBeClearedFromContentOnRemoval()
     {
         // Arrange
-        var component = new TemplatedComponent();
+        var component = new TemplateBox();
         var newBindingContext = new object();
         component.BindingContext = newBindingContext;
         component.ContentTemplate = new DataTemplate(() => new Label());
@@ -117,7 +117,7 @@ public void BindingContextSetThroughBindingContextShouldBeClearedFromContentOnRe
     public void ContentTemplateClearsContentWhenDataTemplateSelectorIsUsedOnAnEmptyContentBindingContext()
     {
         // Arrange
-        var templatedComponent = new TemplatedComponent();
+        var templatedComponent = new TemplateBox();
         var dataTemplateSelector = new TestTemplateSelector();
         var contentBindingContext = "world";
         templatedComponent.ContentBindingContext = contentBindingContext;
@@ -137,7 +137,7 @@ public void ContentTemplateClearsContentWhenDataTemplateSelectorIsUsedOnAnEmptyC
     public void ContentTemplateClearsContentWhenDataTemplateSelectorIsUsedOnAnEmptyBindingContext()
     {
         // Arrange
-        var templatedComponent = new TemplatedComponent();
+        var templatedComponent = new TemplateBox();
         var dataTemplateSelector = new TestTemplateSelector();
         var bindingContext = "world";
         templatedComponent.BindingContext = bindingContext;
@@ -157,7 +157,7 @@ public void ContentTemplateClearsContentWhenDataTemplateSelectorIsUsedOnAnEmptyB
     public void ContentTemplateChangesBindingContextWhenDataTemplateSelectorReturnsTheSameTemplate()
     {
         // Arrange
-        var templatedComponent = new TemplatedComponent();
+        var templatedComponent = new TemplateBox();
         var dataTemplateSelector = new StaticRefTemplateSelector();
         var bindingContext = "world";
         templatedComponent.BindingContext = bindingContext;
@@ -179,18 +179,18 @@ public Task ContentTemplateCanProjectContent()
         => DispatcherTest.RunWithDispatcherStub(() =>
         {
             // Arrange
-            var templatedComponent = new TemplatedComponent();
-            var dataTemplate = new DataTemplate(() => new ProjectContainer());
+            var templatedComponent = new TemplateBox();
+            var dataTemplate = new DataTemplate(() => new TemplateContentPresenter());
             var bindingContext = "world";
             var projectedContent = new Label { Text = "hello" };
             templatedComponent.BindingContext = bindingContext;
             templatedComponent.ContentTemplate = dataTemplate;
 
             // Act
-            templatedComponent.ProjectedContent = projectedContent;
+            templatedComponent.TemplateContent = projectedContent;
 
             // Assert
-            var container = templatedComponent.PresentedContent as ProjectContainer;
+            var container = templatedComponent.PresentedContent as TemplateContentPresenter;
             container.Should().NotBeNull();
             container!.Content.Should().Be(projectedContent);
         });
diff --git a/Tests/Nalu.Maui.Test/Layouts/ToggleTemplateTests.cs b/Tests/Nalu.Maui.Test/Layouts/ToggleTemplateTests.cs
new file mode 100644
index 0000000..9161211
--- /dev/null
+++ b/Tests/Nalu.Maui.Test/Layouts/ToggleTemplateTests.cs
@@ -0,0 +1,71 @@
+namespace Nalu.Maui.Test.Layouts;
+
+public class ToggleTemplateTests
+{
+    [Theory(DisplayName = "ToggleTemplate renders expected template")]
+    [InlineData(true, typeof(Label))]
+    [InlineData(false, typeof(Button))]
+    [InlineData(null, null)]
+    public void ToggleTemplateRendersExpectedTemplate(bool? value, Type? expectedContentType)
+    {
+        // Arrange
+        var toggleTemplate = new ToggleTemplate();
+        var trueTemplate = new DataTemplate(() => new Label());
+        var falseTemplate = new DataTemplate(() => new Button());
+
+        // Act
+        toggleTemplate.WhenTrue = trueTemplate;
+        toggleTemplate.WhenFalse = falseTemplate;
+        toggleTemplate.Value = value;
+
+        // Assert
+        if (expectedContentType != null)
+        {
+            toggleTemplate.PresentedContent.Should().BeOfType(expectedContentType);
+        }
+        else
+        {
+            toggleTemplate.PresentedContent.Should().BeNull();
+        }
+    }
+
+    [Theory(DisplayName = "ToggleTemplate renders expected template when not provided")]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void ToggleTemplateRendersExpectedTemplateWhenNotProvided(bool value)
+    {
+        // Arrange
+        var toggleTemplate = new ToggleTemplate();
+        var trueTemplate = value ? new DataTemplate(() => new Label()) : null;
+        var falseTemplate = value ? null : new DataTemplate(() => new Label());
+
+        // Act
+        toggleTemplate.WhenTrue = trueTemplate;
+        toggleTemplate.WhenFalse = falseTemplate;
+        toggleTemplate.Value = !value;
+
+        // Assert
+        toggleTemplate.PresentedContent.Should().BeNull();
+    }
+
+    [Fact(DisplayName = "ToggleTemplate changes content when value changes")]
+    public void ToggleTemplateChangesContentWhenValueChanges()
+    {
+        // Arrange
+        var toggleTemplate = new ToggleTemplate();
+        var trueTemplate = new DataTemplate(() => new Label { Text = "True" });
+        var falseTemplate = new DataTemplate(() => new Label { Text = "False" });
+        toggleTemplate.WhenTrue = trueTemplate;
+        toggleTemplate.WhenFalse = falseTemplate;
+
+        // Act & Assert
+        toggleTemplate.Value = true;
+        toggleTemplate.PresentedContent.Should().BeOfType<Label>().Which.Text.Should().Be("True");
+
+        toggleTemplate.Value = false;
+        toggleTemplate.PresentedContent.Should().BeOfType<Label>().Which.Text.Should().Be("False");
+
+        toggleTemplate.Value = null;
+        toggleTemplate.PresentedContent.Should().BeNull();
+    }
+}
diff --git a/Tests/Nalu.Maui.Test/Layouts/ComponentTests.cs b/Tests/Nalu.Maui.Test/Layouts/ViewBoxTests.cs
similarity index 90%
rename from Tests/Nalu.Maui.Test/Layouts/ComponentTests.cs
rename to Tests/Nalu.Maui.Test/Layouts/ViewBoxTests.cs
index 6052bda..80d3577 100644
--- a/Tests/Nalu.Maui.Test/Layouts/ComponentTests.cs
+++ b/Tests/Nalu.Maui.Test/Layouts/ViewBoxTests.cs
@@ -1,12 +1,12 @@
 namespace Nalu.Maui.Test.Layouts;
 
-public class ComponentTests
+public class ViewBoxTests
 {
     [Fact(DisplayName = "Content property should set and get content")]
     public void ContentProperty_Should_SetAndGetContent()
     {
         // Arrange
-        var component = new Component();
+        var component = new ViewBox();
         var view = new Label { Text = "Test" };
 
         // Act
@@ -21,7 +21,7 @@ public void ContentProperty_Should_SetAndGetContent()
     public void OnContentPropertyChanged_Should_UpdateContent()
     {
         // Arrange
-        var component = new Component();
+        var component = new ViewBox();
         var oldView = new Label { Text = "Old" };
         var newView = new Label { Text = "New" };
 
@@ -37,7 +37,7 @@ public void OnContentPropertyChanged_Should_UpdateContent()
     public void ContentBindingContextPropertyChangesShouldSetBindingContextOnContent()
     {
         // Arrange
-        var component = new Component();
+        var component = new ViewBox();
         var view = new Label();
         component.Content = view;
         var newBindingContext = new object();
@@ -53,7 +53,7 @@ public void ContentBindingContextPropertyChangesShouldSetBindingContextOnContent
     public void ContentBindingContextPropertyShouldSetBindingContextOnContent()
     {
         // Arrange
-        var component = new Component();
+        var component = new ViewBox();
         var view = new Label();
         var newBindingContext = new object();
         component.ContentBindingContext = newBindingContext;
@@ -69,7 +69,7 @@ public void ContentBindingContextPropertyShouldSetBindingContextOnContent()
     public void BindingContextShouldPropagateToContent()
     {
         // Arrange
-        var component = new Component();
+        var component = new ViewBox();
         var view = new Label();
         var newBindingContext = new object();
         component.BindingContext = newBindingContext;
@@ -85,7 +85,7 @@ public void BindingContextShouldPropagateToContent()
     public void BindingContextShouldBeClearedFromContentOnRemoval()
     {
         // Arrange
-        var component = new Component();
+        var component = new ViewBox();
         var view = new Label();
         var newBindingContext = new object();
         component.BindingContext = newBindingContext;
@@ -102,7 +102,7 @@ public void BindingContextShouldBeClearedFromContentOnRemoval()
     public void BindingContextSetThroughContentBindingContextShouldBeClearedFromContentOnRemoval()
     {
         // Arrange
-        var component = new Component();
+        var component = new ViewBox();
         var view = new Label();
         var newBindingContext = new object();
         component.ContentBindingContext = newBindingContext;
@@ -119,7 +119,7 @@ public void BindingContextSetThroughContentBindingContextShouldBeClearedFromCont
     public void OnPaddingPropertyChanged_Should_InvalidateMeasure()
     {
         // Arrange
-        var component = new Component { IsPlatformEnabled = true };
+        var component = new ViewBox { IsPlatformEnabled = true };
         var newPadding = new Thickness(10);
         var measureInvalidated = false;
         component.MeasureInvalidated += (s, e) => measureInvalidated = true;
diff --git a/docs/index.md b/docs/index.md
index 1eaa085..b31d7fd 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -34,7 +34,7 @@ ValueTask<bool> CanLeaveAsync() => { ... ask the user };
 
 There is an embedded **leak-detector** to help you identify memory leaks in your application.
 
-See more on the [Navigation Wiki](navigation.md).
+**See more on the [Navigation Wiki](navigation.html)**.
 
 ### Layouts [![Nalu.Maui.Layouts NuGet Package](https://img.shields.io/nuget/v/Nalu.Maui.Layouts.svg)](https://www.nuget.org/packages/Nalu.Maui.Layouts/) [![Nalu.Maui NuGet Package Downloads](https://img.shields.io/nuget/dt/Nalu.Maui.Layouts)](https://www.nuget.org/packages/Nalu.Maui.Layouts/)
 
@@ -42,21 +42,21 @@ Cross-platform layouts and utilities for MAUI applications simplify dealing with
 
 - Have you ever dreamed of having an `if` statement in XAML?
   ```csharp
-    <layouts:ConditionedTemplate Value="{Binding HasPermission}"
-                                 TrueTemplate="{StaticResource AdminFormTemplate}"
-                                 FalseTemplate="{StaticResource PermissionRequestTemplate}" />
+    <nalu:ToggleTemplate Value="{Binding HasPermission}"
+                         WhenTrue="{StaticResource AdminFormTemplate}"
+                         WhenFalse="{StaticResource PermissionRequestTemplate}" />
   ```
 - Do you want to scope the binding context of a content?
   ```csharp
-    <layouts:Component ContentBindingContext="{Binding SelectedAnimal}"
-                       IsVisible="{Binding IsSelected}">
+    <nalu:ViewBox ContentBindingContext="{Binding SelectedAnimal}"
+                  IsVisible="{Binding IsSelected}">
         <views:AnimalView x:DataType="models:Animal" />
-    </layouts:Component>
+    </nalu:ViewBox>
   ```
 - And what about rendering a `TemplateSelector` directly like we do on a `CollectionView`?
   ```csharp
-    <layouts:TemplatedComponent ContentTemplateSelector="{StaticResource AnimalTemplateSelector}"
-                                ContentBindingContext="{Binding CurrentAnimal}" />
+    <nalu:TemplateBox ContentTemplateSelector="{StaticResource AnimalTemplateSelector}"
+                      ContentBindingContext="{Binding CurrentAnimal}" />
   ```
 
-Find out more on the [Layouts Wiki](layouts.md).
+**Find out more on the [Layouts Wiki](layouts.html)**.
diff --git a/docs/layouts.md b/docs/layouts.md
index 2a3dbd2..c430c4c 100644
--- a/docs/layouts.md
+++ b/docs/layouts.md
@@ -4,66 +4,69 @@ Cross-platform layouts for MAUI applications to simplify dealing with templates
 
 Can be added to your project using `.UseNaluLayouts()` on your app builder.
 
-### Component
+### ViewBox
 
-`Component` is a lightweight replacement for `ContentView` class which is still based on the legacy Xamarin `Compatibility.Layout`.
-You can simply use `Component` as base class of your custom views instead of using `ContentView`.
+`ViewBox` is a lightweight replacement for `ContentView` class which is still based on the legacy Xamarin `Compatibility.Layout`.
+You can simply use `ViewBox` as base class of your custom views instead of using `ContentView`.
 
-This class also provides a `ContentBindingContext` property that allows you to bind the content to a property of the `Component`'s binding context.
+This class also provides a `ContentBindingContext` property that allows you to bind the content to a property of the `ViewBox`'s binding context.
 This helps to fulfill interface segregation principle.
 
 ```xml
-<layouts:Component ContentBindingContext="{Binding SelectedAnimal}"
-                   IsVisible="{Binding IsSelected}">
+<nalu:ViewBox ContentBindingContext="{Binding SelectedAnimal}"
+              IsVisible="{Binding IsSelected}">
     <views:AnimalView x:DataType="models:Animal" />
-</layouts:Component>
+</nalu:ViewBox>
 ```
 
-### TemplatedComponent
+### TemplateBox
 
-A `Component` that generates a content view based on `DataTemplate` or `DataTemplateSelector`.
+Similarly to `ViewBox` this component holds a view based on `DataTemplate` or `DataTemplateSelector`.
 
 ```xml
-<layouts:TemplatedComponent ContentTemplate="{StaticResource AnimalTemplate}" ContentBindingContext="{Binding CurrentAnimal}" />
-<!-- or -->
-<layouts:TemplatedComponent ContentTemplate="{StaticResource AnimalTemplateSelector}" ContentBindingContext="{Binding CurrentAnimal}" />
+<nalu:TemplateBox ContentTemplate="{StaticResource AnimalTemplate}" ContentBindingContext="{Binding CurrentAnimal}" />
 ```
+```xml
+<nalu:TemplateBox ContentTemplate="{StaticResource AnimalTemplateSelector}" ContentBindingContext="{Binding CurrentAnimal}" />
+```
+
+You can also project the content into the template (like you usually do with [ContentPresenter](https://learn.microsoft.com/en-us/dotnet/maui/fundamentals/controltemplate?view=net-maui-8.0#substitute-content-into-a-contentpresenter)).
 
-You can also project the content into the template. The following example will display `Projected => I'm here!`.
+The following example will display `Projected => I'm here!`.
 
 ```xml
-<layouts:TemplatedComponent>
+<nalu:TemplateBox>
 
-    <layouts:TemplatedComponent.ContentTemplate>
+    <nalu:TemplateBox.ContentTemplate>
         <DataTemplate>
             <HorizontalStackLayout>
                 <Label Text="Projected => " />
-                <layouts:ProjectContainer />
+                <nalu:TemplateContentPresenter />
             </HorizontalStackLayout>
         </DataTemplate>
-    </layouts:TemplatedComponent.ContentTemplate>
+    </nalu:TemplateBox.ContentTemplate>
 
     <Label Text="I'm here!" />
 
-</layouts:TemplatedComponent>
+</nalu:TemplateBox>
 ```
 
-### ConditionedTemplate
+### ToggleTemplate
 
 Usually to switch between views we use `IsVisible` property, but this is not always the best solution.
-Using `IsVisible` still creates the view in the visual tree applying all the bindings.
-`ConditionedTemplate` is a `TemplatedComponent` that generates a content view based on a boolean value and corresponding template(s).
+Using `IsVisible` still creates the view in the visual tree applying all the bindings (performance impact).
+`ToggleTemplate` is a `TemplateBox` that generates a content view based on a boolean value and a corresponding `DataTemplate` (or even `DataTemplateSelector`).
 
 ```xml
-<layouts:ConditionedTemplate Value="{Binding HasPermission}"
-                             TrueTemplate="{StaticResource AdminFormTemplate}"
-                             FalseTemplate="{StaticResource PermissionRequestTemplate}" />
+<nalu:ToggleTemplate Value="{Binding HasPermission}"
+                     WhenTrue="{StaticResource AdminFormTemplate}"
+                     WhenFalse="{StaticResource PermissionRequestTemplate}" />
 ```
 
 This can also be used with one single expensive template:
 ```xml
-<layouts:ConditionedTemplate Value="{Binding ShowExpensiveTemplate}"
-                             TrueTemplate="{StaticResource ExpensiveTemplate}" />
+<nalu:ToggleTemplate Value="{Binding ShowExpensiveTemplate}"
+                     WhenTrue="{StaticResource ExpensiveTemplate}" />
 ```
 
 
diff --git a/docs/navigation.md b/docs/navigation.md
index ce02c2a..0d8b38c 100644
--- a/docs/navigation.md
+++ b/docs/navigation.md
@@ -237,13 +237,13 @@ With Nalu navigation you can also pass parameters to the target page using the `
 - `IEnteringAware<TIntent>`: defines a `ValueTask OnEnteringAsync(TIntent intent)` called when the page is entering the navigation stack
 - `IAppearingAware<TIntent>`: defines a `ValueTask OnAppearingAsync(TIntent intent)` called when the page is appearing
 
-Note: when an intent is passed to the view model, the `OnEnteringAsync` and `OnAppearingAsync` parameterless methods will not be called,
-unless you explicitly configure Nalu with `Fallthrough` behavior.
+Note: when an intent is passed to the view model, the `OnEnteringAsync` and `OnAppearingAsync` parameterless methods will be invoked only if the intent-specific method is not implemented.
+You can change this behavior by configuring Nalu with `Strict` behavior.
 
 ```csharp
 .UseNaluNavigation<App>(nav => nav
     .AddPages()
-    .WithNavigationIntentBehavior(NavigationIntentBehavior.Fallthrough)
+    .WithNavigationIntentBehavior(NavigationIntentBehavior.Strict)
 )
 ```