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,126 @@
+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();
+        // Capture the token up front, before DisposeAsync (which can run concurrently and dispose
+        // the source) gets a chance to. Reading cts.Token later inside RemoveAfterDelay would risk
+        // an ObjectDisposedException if the component is torn down before the delay is queued.
+        var token = cts.Token;
+        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(() =>
+        {
+            // DisposeAsync cancels every queued token; if it ran between scheduling this callback
+            // and it executing, bail out before touching _toasts/StateHasChanged so no UI work (or
+            // RemoveAfterDelay timer) starts after the component has been torn down.
+            if (token.IsCancellationRequested)
+                return;
+
+            _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, token);
+        });
+    }
+
+    private async Task RemoveAfterDelay(int id, CancellationTokenSource cts, CancellationToken token)
+    {
+        try
+        {
+            try
+            {
+                await Task.Delay(3000, token);
+            }
+            catch (OperationCanceledException)
+            {
+                return;
+            }
+
+            // Final cancellation check before the dispatcher hop: DisposeAsync may have cancelled the
+            // token after Task.Delay completed but before we queue the render. Bail out so _toasts and
+            // StateHasChanged are never touched once teardown has started.
+            if (token.IsCancellationRequested)
+                return;
+
+            // Mutate the toast list on the renderer's dispatcher to avoid racing the template's foreach.
+            await InvokeAsync(() =>
+            {
+                // Re-check inside the dispatcher callback: DisposeAsync can cancel after the check
+                // above but before this lambda runs, so no-op once teardown has begun instead of
+                // mutating _toasts / calling StateHasChanged on a disposed component.
+                if (token.IsCancellationRequested)
+                    return;
+
+                _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>