feat(core,ui): add configurable Bootstrap text and JTabView component (#624)

* feat(core): add configurable Bootstrap text via BootstrapText struct

Add a serializable BootstrapText struct that externalizes all ~30
user-facing strings from Bootstrap, enabling per-project localization
and branding without modifying framework code.

Closes #622

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: JasonXuDeveloper - 傑 <jason@xgamedev.net>

* fix(core): address code review feedback

- Add BootstrapText.SafeFormat helper with try/catch fallback for
  malformed user-edited format strings
- Replace all string.Format calls with SafeFormat in Bootstrap.cs
- Use nameof(BootstrapText.*) instead of string literals in editor UI
- Use BindProperty for JTextField binding (proper undo/prefab support)
- Add tests for SafeFormat, Default field validation, exact field count,
  sub-headers, and reset logic

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: JasonXuDeveloper - 傑 <jason@xgamedev.net>

* feat(ui): add JTabView component and improve editor UI test coverage

- Add JTabView tabbed container component with configurable maxTabsPerRow
- Refactor BootstrapEditorUI Text Settings into 6 categorized tabs (3x2 grid)
- Add 46 new tests across 8 components using reflection for private methods
  (JButton, JCard, JObjectField, JTextField, JDropdown, JStack, JTabView,
  BootstrapEditorUI)
- Update GitHub instructions to require 93%+ coverage for non-core packages
  with support for both EditMode and non-interactive PlayMode tests

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: JasonXuDeveloper - 傑 <jason@xgamedev.net>

* chore: update compiled build output

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: JasonXuDeveloper - 傑 <jason@xgamedev.net>

* style(ui): add explicit parentheses for arithmetic precedence

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: JasonXuDeveloper - 傑 <jason@xgamedev.net>

* fix(core,ui): address code review feedback

- Add null guard to BootstrapText.SafeFormat for null templates
- Make JTabView._maxTabsPerRow readonly
- Use evt.currentTarget instead of evt.target in JTabView handlers
- Add SafeFormat null template test

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: JasonXuDeveloper - 傑 <jason@xgamedev.net>

* fix(ui): use reflection for currentTarget setter in tests

The currentTarget setter is internal in UIElements. Use reflection
with a null check so tests gracefully skip if the API changes.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: JasonXuDeveloper - 傑 <jason@xgamedev.net>

---------

Signed-off-by: JasonXuDeveloper - 傑 <jason@xgamedev.net>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: JasonXuDeveloper

.github/instructions/code-review.instructions.md

@@ -43,8 +43,19 @@ Avoid LINQ in hot paths and UI code for performance:
 - Use array/list indexing instead of `.First()` / `.Last()`
 - LINQ allocates iterators and delegates - avoid in frequently called code
 
+### 7. Unit Test Coverage
+New features and new logic in non-core packages (JEngine.UI, JEngine.Util, and any future packages) MUST include unit tests:
+- Target **93%+ code coverage** for all new/modified code
+- **Applies to**: All `Packages/com.jasonxudeveloper.jengine.*` packages **except** `jengine.core`
+- Prefer **EditMode tests** (`Tests/Editor/`) for most logic
+- Use **PlayMode tests** (`Tests/Runtime/`) when runtime behavior requires it (MonoBehaviour lifecycle, scene loading, etc.) — these must run **non-interactively** (no user input, no manual scene setup)
+- Cover: constructors, public API, fluent chaining, edge cases, event handlers
+- Use reflection to test private methods (e.g. `OnAttachToPanel`, hover handlers) when they contain meaningful logic
+- Verify tests exercise both happy paths and error/boundary conditions
+
 ## Common Issues to Flag
 
+- Missing or insufficient unit tests for new features
 - Missing XML documentation on public APIs
 - Direct `Debug.Log` (should use proper logging)
 - `Task` instead of `UniTask`

.github/instructions/jengine.instructions.md

@@ -102,6 +102,84 @@ internal class MyEditorClass
 }
 ```
 
+## Unit Testing
+
+### Scope
+Unit tests are required for all non-core JEngine packages — i.e. any package under `Packages/com.jasonxudeveloper.jengine.*` **except** `jengine.core`. This includes JEngine.UI, JEngine.Util, and any future packages.
+
+### Coverage Requirement
+New features and new logic MUST include unit tests targeting **93%+ code coverage**:
+- All public methods, properties, and constructors
+- Fluent API chaining
+- Edge cases and error conditions
+- Event handlers and callbacks (use reflection for private handlers)
+
+### Test Modes
+- **EditMode tests** (`Tests/Editor/`): Preferred for most logic — fast, no scene required.
+- **PlayMode tests** (`Tests/Runtime/`): Use when the test needs a running game loop, MonoBehaviour lifecycle, or scene loading. PlayMode tests **must run non-interactively** (no user input, no manual scene setup). Use `[UnityTest]` with `UniTask.ToCoroutine()` for async PlayMode tests.
+
+### Test Location
+Tests mirror the source structure under each package's test folders:
+```
+Packages/com.jasonxudeveloper.jengine.ui/Editor/Components/Button/JButton.cs
+  → Packages/com.jasonxudeveloper.jengine.ui/Tests/Editor/Components/Button/JButtonTests.cs
+
+Packages/com.jasonxudeveloper.jengine.util/Runtime/JAction.cs
+  → Packages/com.jasonxudeveloper.jengine.util/Tests/Editor/JActionTests.cs
+
+# PlayMode tests when runtime behavior requires it:
+Packages/com.jasonxudeveloper.jengine.util/Runtime/SomeFeature.cs
+  → Packages/com.jasonxudeveloper.jengine.util/Tests/Runtime/SomeFeatureTests.cs
+```
+
+### EditMode Test Pattern
+```csharp
+[TestFixture]
+public class MyComponentTests
+{
+    private MyComponent _component;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _component = new MyComponent();
+    }
+
+    [Test]
+    public void Constructor_Default_AddsBaseClass()
+    {
+        Assert.IsTrue(_component.ClassListContains("my-component"));
+    }
+}
+```
+
+### PlayMode Test Pattern
+PlayMode tests must be fully automated — no interactive input or manual scene setup:
+```csharp
+[TestFixture]
+public class MyRuntimeTests
+{
+    [UnityTest]
+    public IEnumerator MyAsyncTest() => UniTask.ToCoroutine(async () =>
+    {
+        var go = new GameObject();
+        var component = go.AddComponent<MyBehaviour>();
+        await UniTask.DelayFrame(1);
+        Assert.IsTrue(component.IsInitialized);
+        Object.Destroy(go);
+    });
+}
+```
+
+### Testing Private Methods via Reflection
+For private event handlers and internal styling methods:
+```csharp
+var method = typeof(MyComponent).GetMethod("OnMouseEnter",
+    BindingFlags.NonPublic | BindingFlags.Instance);
+method.Invoke(_component, new object[] { null });
+Assert.AreEqual(expectedColor, _component.style.backgroundColor.value);
+```
+
 ## Review Focus Areas
 
 When reviewing JEngine code, check:
@@ -110,3 +188,4 @@ When reviewing JEngine code, check:
 3. Resource cleanup (ScriptableObjects, events)
 4. Thread safety for callback-accessed state
 5. Proper namespace usage
+6. Unit tests with 93%+ coverage for new features/logic