Add BitFullCalendar extras component (#12449)

src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFcCalendarBody.razor

@@ -0,0 +1,44 @@
+@namespace Bit.BlazorUI
+@implements IDisposable
+
+<div class="bit-bfc-body" @key="(State.Mode, State.View)">
+    @if (State.Mode == BitFullCalendarMode.Timeline)
+    {
+        switch (State.View)
+        {
+            case BitFullCalendarView.Day:
+                <BitFcTimelineDayView Events="_timelineEvents" EventTemplate="TimelineEventTemplate" />
+                break;
+            case BitFullCalendarView.Week:
+                <BitFcTimelineWeekView Events="_timelineEvents" EventTemplate="TimelineEventTemplate" />
+                break;
+            case BitFullCalendarView.Month:
+                <BitFcTimelineMonthView Events="_timelineEvents" EventTemplate="TimelineEventTemplate" />
+                break;
+            default:
+                <BitFcTimelineWeekView Events="_timelineEvents" EventTemplate="TimelineEventTemplate" />
+                break;
+        }
+    }
+    else
+    {
+        switch (State.View)
+        {
+            case BitFullCalendarView.Month:
+                <BitFcCalendarMonthView SingleDayEvents="_singleDayEvents" MultiDayEvents="_multiDayEvents" EventTemplate="MonthEventTemplate" />
+                break;
+            case BitFullCalendarView.Week:
+                <BitFcCalendarWeekView SingleDayEvents="_singleDayEvents" MultiDayEvents="_multiDayEvents" EventTemplate="WeekEventTemplate" />
+                break;
+            case BitFullCalendarView.Day:
+                <BitFcCalendarDayView SingleDayEvents="_singleDayEvents" MultiDayEvents="_multiDayEvents" EventTemplate="DayEventTemplate" />
+                break;
+            case BitFullCalendarView.Year:
+                <BitFcCalendarYearView SingleDayEvents="_singleDayEvents" MultiDayEvents="_multiDayEvents" />
+                break;
+            case BitFullCalendarView.Agenda:
+                <BitFcAgendaEvents />
+                break;
+        }
+    }
+</div>

src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFcCalendarBody.razor.cs

@@ -0,0 +1,36 @@
+namespace Bit.BlazorUI;
+
+public partial class BitFcCalendarBody
+{
+    [CascadingParameter] public BitFullCalendarState State { get; set; } = default!;
+
+    [Parameter] public RenderFragment<BitFullCalendarEvent>? MonthEventTemplate { get; set; }
+    [Parameter] public RenderFragment<BitFullCalendarEvent>? WeekEventTemplate { get; set; }
+    [Parameter] public RenderFragment<BitFullCalendarEvent>? DayEventTemplate { get; set; }
+    [Parameter] public RenderFragment<BitFullCalendarEvent>? TimelineEventTemplate { get; set; }
+
+    private List<BitFullCalendarEvent> _singleDayEvents = [];
+    private List<BitFullCalendarEvent> _multiDayEvents = [];
+    private List<BitFullCalendarEvent> _timelineEvents = [];
+
+    protected override void OnInitialized()
+    {
+        State.OnStateChanged += Refresh;
+        ComputeEvents();
+    }
+
+    private void Refresh()
+    {
+        ComputeEvents();
+        InvokeAsync(StateHasChanged);
+    }
+
+    private void ComputeEvents()
+    {
+        _singleDayEvents = State.Events.Where(e => e.IsSingleDay).ToList();
+        _multiDayEvents = State.Events.Where(e => e.IsMultiDay).ToList();
+        _timelineEvents = State.Events.ToList();
+    }
+
+    public void Dispose() => State.OnStateChanged -= Refresh;
+}

src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFcCalendarToast.razor

@@ -0,0 +1,10 @@
+@namespace Bit.BlazorUI
+
+<div class="bit-bfc-toast-container" aria-live="polite">
+    @foreach (var toast in _toasts)
+    {
+        <div @key="toast.Id" class="bit-bfc-toast @(toast.IsError ? "error" : "success")" role="@(toast.IsError ? "alert" : "status")">
+            @toast.Message
+        </div>
+    }
+</div>

src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFcCalendarToast.razor.cs

@@ -0,0 +1,104 @@
+namespace Bit.BlazorUI;
+
+public partial class BitFcCalendarToast : IAsyncDisposable
+{
+    private readonly List<ToastItem> _toasts = [];
+    private readonly List<CancellationTokenSource> _removalTokens = [];
+    private readonly object _removalTokensLock = new();
+    private int _nextId;
+
+    public void Show(string message, bool isError = false)
+    {
+        // Allocate the id atomically: Show can be invoked off the renderer thread (the list mutation
+        // is marshalled below, but the id is assigned here on the caller's thread), so a plain
+        // _nextId++ could hand out duplicate ids under concurrent calls and break RemoveAfterDelay's
+        // per-id removal.
+        var item = new ToastItem { Id = Interlocked.Increment(ref _nextId), Message = message, IsError = isError };
+
+        var cts = new CancellationTokenSource();
+        lock (_removalTokensLock)
+        {
+            _removalTokens.Add(cts);
+        }
+
+        // Marshal the list mutation and render onto the renderer's dispatcher so the whole toast
+        // lifecycle (add here, remove in RemoveAfterDelay) stays dispatcher-safe even when Show is
+        // invoked from a non-renderer thread.
+        _ = InvokeAsync(() =>
+        {
+            _toasts.Add(item);
+            StateHasChanged();
+            // Start the expiration timer only after the toast has actually been queued into the UI,
+            // so the 3s lifetime begins from when it becomes visible rather than from when Show was
+            // scheduled (which may run on a non-renderer thread before the add is dispatched).
+            _ = RemoveAfterDelay(item.Id, cts);
+        });
+    }
+
+    private async Task RemoveAfterDelay(int id, CancellationTokenSource cts)
+    {
+        try
+        {
+            try
+            {
+                await Task.Delay(3000, cts.Token);
+            }
+            catch (OperationCanceledException)
+            {
+                return;
+            }
+
+            // Mutate the toast list on the renderer's dispatcher to avoid racing the template's foreach.
+            await InvokeAsync(() =>
+            {
+                _toasts.RemoveAll(t => t.Id == id);
+                StateHasChanged();
+            });
+        }
+        finally
+        {
+            // Drop the token as soon as its timer finishes (or is cancelled) so _removalTokens
+            // doesn't grow unbounded on long-lived pages that show many toasts.
+            bool removed;
+            lock (_removalTokensLock)
+            {
+                removed = _removalTokens.Remove(cts);
+            }
+            if (removed)
+                cts.Dispose();
+        }
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        // Snapshot under the lock: RemoveAfterDelay also removes/disposes tokens as their timers
+        // complete, so reading the live list here could race with that cleanup.
+        CancellationTokenSource[] tokens;
+        lock (_removalTokensLock)
+        {
+            tokens = _removalTokens.ToArray();
+            _removalTokens.Clear();
+        }
+
+        foreach (var cts in tokens)
+        {
+            try
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+                // Already disposed by RemoveAfterDelay's cleanup; nothing to do.
+            }
+        }
+        return ValueTask.CompletedTask;
+    }
+
+    private class ToastItem
+    {
+        public int Id { get; set; }
+        public string Message { get; set; } = "";
+        public bool IsError { get; set; }
+    }
+}

src/BlazorUI/Bit.BlazorUI.Extras/Components/FullCalendar/BitFullCalendar.razor

@@ -0,0 +1,12 @@
+@namespace Bit.BlazorUI
+
+<BitCascadingValueProvider ValueList="BuildCascadingValues()">
+    <div class="bit-bfc" dir="@(State.IsRtl ? "rtl" : "ltr")">
+        <BitFcCalendarHeader />
+        <BitFcCalendarBody MonthEventTemplate="MonthEventTemplate"
+                           WeekEventTemplate="WeekEventTemplate"
+                           DayEventTemplate="DayEventTemplate"
+                           TimelineEventTemplate="TimelineEventTemplate" />
+        <BitFcCalendarToast />
+    </div>
+</BitCascadingValueProvider>