feat: Add asset inclusion strategy and link detection for markdown processing

Author: Arlodotexe

src/Blog/Assets/ReferenceOnlyInclusionStrategy.cs

@@ -0,0 +1,26 @@
+using OwlCore.Storage;
+
+namespace WindowsAppCommunity.Blog.Assets;
+
+/// <summary>
+/// Reference-only inclusion strategy: always rewrites paths to add one level of parent navigation,
+/// treating all assets as externally referenced (not included in page folder).
+/// </summary>
+public sealed class ReferenceOnlyInclusionStrategy : IAssetInclusionStrategy
+{
+    /// <inheritdoc/>
+    public Task<string> DecideAsync(
+        IFile referencingMarkdown,
+        IFile referencedAsset,
+        string originalPath,
+        CancellationToken ct = default)
+    {
+        // Reference-only behavior: add one parent directory prefix to account for folderization
+        // Markdown file becomes folder/index.html, so links need one extra "../" to reach original location
+        if (string.IsNullOrWhiteSpace(originalPath))
+            return Task.FromResult(originalPath);
+
+        var rewrittenPath = "../" + originalPath;
+        return Task.FromResult(rewrittenPath);
+    }
+}

src/Blog/Assets/RegexAssetLinkDetector.cs

@@ -0,0 +1,55 @@
+using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
+using OwlCore.Storage;
+
+namespace WindowsAppCommunity.Blog.Assets;
+
+/// <summary>
+/// Detects relative asset links in rendered HTML using path-pattern regex (no element parsing).
+/// </summary>
+public sealed partial class RegexAssetLinkDetector : IAssetLinkDetector
+{
+    /// <summary>
+    /// Regex pattern for relative path segments: alphanumerics, underscore, hyphen, dot.
+    /// Matches paths with optional ./ or ../ prefixes and / or \ separators.
+    /// </summary>
+    [GeneratedRegex(@"(?<![A-Za-z0-9_\-\.])(?:(?:\./)|(?:\.\./)+)?[A-Za-z0-9_\-\.]+(?:[\/\\][A-Za-z0-9_\-\.]+)*(?![A-Za-z0-9_\-\.])", RegexOptions.Compiled)]
+    private static partial Regex RelativePathPattern();
+
+    /// <inheritdoc/>
+    public async IAsyncEnumerable<string> DetectAsync(IFile htmlSource, [EnumeratorCancellation] CancellationToken ct = default)
+    {
+        // Read HTML content
+        using var stream = await htmlSource.OpenStreamAsync(FileAccess.Read, ct);
+        using var reader = new StreamReader(stream);
+        var html = await reader.ReadToEndAsync(ct);
+
+        // Find all matches
+        var matches = RelativePathPattern().Matches(html);
+
+        foreach (Match match in matches)
+        {
+            if (ct.IsCancellationRequested)
+                yield break;
+
+            var path = match.Value;
+
+            // Filter out non-relative patterns
+            if (string.IsNullOrWhiteSpace(path))
+                continue;
+
+            // Exclude absolute schemes
+            if (path.StartsWith("http://", StringComparison.OrdinalIgnoreCase) ||
+                path.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ||
+                path.StartsWith("data:", StringComparison.OrdinalIgnoreCase) ||
+                path.StartsWith("//", StringComparison.Ordinal))
+                continue;
+
+            // Exclude absolute root paths (optional - treating these as non-relative)
+            if (path.StartsWith('/') || path.StartsWith('\\'))
+                continue;
+
+            yield return path;
+        }
+    }
+}

src/Blog/Assets/RelativePathAssetResolver.cs

@@ -0,0 +1,41 @@
+using OwlCore.Storage;
+
+namespace WindowsAppCommunity.Blog.Assets;
+
+/// <summary>
+/// Resolves relative paths to IFile instances using source folder and markdown file context.
+/// Paths are resolved relative to the markdown file's location (pre-folderization).
+/// </summary>
+public sealed class RelativePathAssetResolver : IAssetResolver
+{
+    /// <inheritdoc/>
+    public required IFolder SourceFolder { get; init; }
+
+    /// <inheritdoc/>
+    public required IFile MarkdownSource { get; init; }
+
+    /// <inheritdoc/>
+    public async Task<IFile?> ResolveAsync(string relativePath, CancellationToken ct = default)
+    {
+        if (string.IsNullOrWhiteSpace(relativePath))
+            return null;
+
+        try
+        {
+            // Normalize path separators to forward slash
+            var normalizedPath = relativePath.Replace('\\', '/');
+
+            // Resolve relative to markdown file's location (pre-folderization)
+            // The markdown file itself is the base for relative path resolution
+            var item = await MarkdownSource.GetItemByRelativePathAsync(normalizedPath, ct);
+
+            // Return only if it's a file
+            return item as IFile;
+        }
+        catch
+        {
+            // Path resolution failed (invalid path, not found, etc.)
+            return null;
+        }
+    }
+}