chore: release v2.4

- Add theme system (Dark/Light palettes, ModernTheme, ThemeManager)
- Add InputDialog, Spinner common view
- Add DuplicatesCsvExportService
- Refresh views, dialogs, and view models across tabs
- Update localization strings (en/fr)
- Tweak services (transfer, permissions, search, user access, ownership elevation, bulk operations)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

SharepointToolbox/Core/Helpers/SharePointPaginationHelper.cs

@@ -6,9 +6,12 @@ namespace SharepointToolbox.Core.Helpers;
 
 public static class SharePointPaginationHelper
 {
+    // Max page size SharePoint honors with Paged='TRUE' (threshold bypass).
+    private const int DefaultRowLimit = 5000;
+
     /// <summary>
     /// Enumerates all items in a SharePoint list, bypassing the 5,000-item threshold.
-    /// Uses CamlQuery with RowLimit=2000 and ListItemCollectionPosition for pagination.
+    /// Uses CamlQuery with Paged='TRUE' RowLimit and ListItemCollectionPosition for pagination.
     /// Never call ExecuteQuery directly on a list — always use this helper.
     /// </summary>
     public static async IAsyncEnumerable<ListItem> GetAllItemsAsync(
@@ -18,7 +21,7 @@ public static class SharePointPaginationHelper
         [EnumeratorCancellation] CancellationToken ct = default)
     {
         var query = baseQuery ?? CamlQuery.CreateAllItemsQuery();
-        query.ViewXml = BuildPagedViewXml(query.ViewXml, rowLimit: 2000);
+        query.ViewXml = BuildPagedViewXml(query.ViewXml, DefaultRowLimit);
         query.ListItemCollectionPosition = null;
 
         do
@@ -36,21 +39,75 @@ public static class SharePointPaginationHelper
         while (query.ListItemCollectionPosition != null);
     }
 
+    /// <summary>
+    /// Enumerates items within a specific folder (direct children by default, or
+    /// recursive when <paramref name="recursive"/> is true). Uses paginated CAML
+    /// with no WHERE clause so it works on libraries above the 5,000-item threshold.
+    /// Callers filter by FSObjType client-side via the returned ListItem fields.
+    /// </summary>
+    public static async IAsyncEnumerable<ListItem> GetItemsInFolderAsync(
+        ClientContext ctx,
+        List list,
+        string folderServerRelativeUrl,
+        bool recursive,
+        string[]? viewFields = null,
+        [EnumeratorCancellation] CancellationToken ct = default)
+    {
+        var fields = viewFields ?? new[]
+        {
+            "FSObjType", "FileRef", "FileLeafRef", "FileDirRef", "File_x0020_Size"
+        };
+
+        var viewFieldsXml = string.Join(string.Empty,
+            fields.Select(f => $"<FieldRef Name='{f}' />"));
+
+        var scope = recursive ? " Scope='RecursiveAll'" : string.Empty;
+        var viewXml =
+            $"<View{scope}>" +
+              "<Query></Query>" +
+              $"<ViewFields>{viewFieldsXml}</ViewFields>" +
+              $"<RowLimit Paged='TRUE'>{DefaultRowLimit}</RowLimit>" +
+            "</View>";
+
+        var query = new CamlQuery
+        {
+            ViewXml = viewXml,
+            FolderServerRelativeUrl = folderServerRelativeUrl,
+            ListItemCollectionPosition = null
+        };
+
+        do
+        {
+            ct.ThrowIfCancellationRequested();
+            var items = list.GetItems(query);
+            ctx.Load(items);
+            await ctx.ExecuteQueryAsync();
+
+            foreach (var item in items)
+                yield return item;
+
+            query.ListItemCollectionPosition = items.ListItemCollectionPosition;
+        }
+        while (query.ListItemCollectionPosition != null);
+    }
+
     internal static string BuildPagedViewXml(string? existingXml, int rowLimit)
     {
-        // Inject or replace RowLimit in existing CAML, or create minimal view
         if (string.IsNullOrWhiteSpace(existingXml))
-            return $"<View><RowLimit>{rowLimit}</RowLimit></View>";
+            return $"<View><RowLimit Paged='TRUE'>{rowLimit}</RowLimit></View>";
 
-        // Simple replacement approach — adequate for Phase 1
-        if (existingXml.Contains("<RowLimit>", StringComparison.OrdinalIgnoreCase))
+        // Replace any existing <RowLimit ...>n</RowLimit> with paged form.
+        if (System.Text.RegularExpressions.Regex.IsMatch(
+                existingXml, @"<RowLimit[^>]*>\d+</RowLimit>",
+                System.Text.RegularExpressions.RegexOptions.IgnoreCase))
         {
             return System.Text.RegularExpressions.Regex.Replace(
                 existingXml, @"<RowLimit[^>]*>\d+</RowLimit>",
-                $"<RowLimit>{rowLimit}</RowLimit>",
+                $"<RowLimit Paged='TRUE'>{rowLimit}</RowLimit>",
                 System.Text.RegularExpressions.RegexOptions.IgnoreCase);
         }
-        return existingXml.Replace("</View>", $"<RowLimit>{rowLimit}</RowLimit></View>",
+        return existingXml.Replace("</View>",
+            $"<RowLimit Paged='TRUE'>{rowLimit}</RowLimit></View>",
             StringComparison.OrdinalIgnoreCase);
     }
 }

SharepointToolbox/Core/Models/AppSettings.cs

@@ -5,4 +5,5 @@ public class AppSettings
     public string DataFolder { get; set; } = string.Empty;
     public string Lang { get; set; } = "en";
     public bool AutoTakeOwnership { get; set; } = false;
+    public string Theme { get; set; } = "System"; // System | Light | Dark
 }

SharepointToolbox/Core/Models/DuplicateItem.cs

@@ -10,4 +10,8 @@ public class DuplicateItem
     public DateTime? Modified { get; set; }
     public int? FolderCount { get; set; }
     public int? FileCount { get; set; }
+    /// <summary>URL of the site the item was collected from.</summary>
+    public string SiteUrl { get; set; } = string.Empty;
+    /// <summary>Friendly site title; falls back to a derived label when unknown.</summary>
+    public string SiteTitle { get; set; } = string.Empty;
 }

SharepointToolbox/Core/Models/OperationProgress.cs

@@ -1,7 +1,7 @@
 namespace SharepointToolbox.Core.Models;
 
-public record OperationProgress(int Current, int Total, string Message)
+public record OperationProgress(int Current, int Total, string Message, bool IsIndeterminate = false)
 {
     public static OperationProgress Indeterminate(string message) =>
-        new(0, 0, message);
+        new(0, 0, message, IsIndeterminate: true);
 }

SharepointToolbox/Core/Models/SiteInfo.cs

@@ -1,3 +1,42 @@
 namespace SharepointToolbox.Core.Models;
 
-public record SiteInfo(string Url, string Title);
+public record SiteInfo(string Url, string Title)
+{
+    public long StorageUsedMb { get; init; }
+    public long StorageQuotaMb { get; init; }
+    public string Template { get; init; } = string.Empty;
+
+    public SiteKind Kind => SiteKindHelper.FromTemplate(Template);
+}
+
+public enum SiteKind
+{
+    Unknown,
+    TeamSite,
+    CommunicationSite,
+    Classic
+}
+
+public static class SiteKindHelper
+{
+    public static SiteKind FromTemplate(string template)
+    {
+        if (string.IsNullOrEmpty(template)) return SiteKind.Unknown;
+        if (template.StartsWith("GROUP#", StringComparison.OrdinalIgnoreCase)) return SiteKind.TeamSite;
+        if (template.StartsWith("SITEPAGEPUBLISHING#", StringComparison.OrdinalIgnoreCase)) return SiteKind.CommunicationSite;
+        if (template.StartsWith("STS#", StringComparison.OrdinalIgnoreCase)) return SiteKind.Classic;
+        return SiteKind.Unknown;
+    }
+
+    public static string DisplayName(SiteKind kind)
+    {
+        var key = kind switch
+        {
+            SiteKind.TeamSite => "sitepicker.kind.teamsite",
+            SiteKind.CommunicationSite => "sitepicker.kind.communication",
+            SiteKind.Classic => "sitepicker.kind.classic",
+            _ => "sitepicker.kind.other"
+        };
+        return Localization.TranslationSource.Instance[key];
+    }
+}

SharepointToolbox/Core/Models/TransferJob.cs

@@ -10,4 +10,24 @@ public class TransferJob
     public string DestinationFolderPath { get; set; } = string.Empty;
     public TransferMode Mode { get; set; } = TransferMode.Copy;
     public ConflictPolicy ConflictPolicy { get; set; } = ConflictPolicy.Skip;
+
+    /// <summary>
+    /// Optional library-relative file paths. When non-empty, only these files
+    /// are transferred; SourceFolderPath recursive enumeration is skipped.
+    /// </summary>
+    public IReadOnlyList<string> SelectedFilePaths { get; set; } = Array.Empty<string>();
+
+    /// <summary>
+    /// When true, recreate the source folder name under the destination folder
+    /// (dest/srcFolderName/... ). When false, the source folder's contents land
+    /// directly inside the destination folder.
+    /// </summary>
+    public bool IncludeSourceFolder { get; set; }
+
+    /// <summary>
+    /// When true (default), transfer the files inside the source folder.
+    /// When false, only create the folder structure (useful together with
+    /// <see cref="IncludeSourceFolder"/> to clone an empty scaffold).
+    /// </summary>
+    public bool CopyFolderContents { get; set; } = true;
 }