+
+
+@section Scripts {
+
+
+}
+
+@section Styles {
+
+
+}
\ No newline at end of file
diff --git a/JoshHeaps.Net/Pages/Chess.cshtml.cs b/JoshHeaps.Net/Pages/Chess.cshtml.cs
new file mode 100644
index 0000000..86b663b
--- /dev/null
+++ b/JoshHeaps.Net/Pages/Chess.cshtml.cs
@@ -0,0 +1,12 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace JoshHeaps.Net.Pages
+{
+ public class ChessModel : PageModel
+ {
+ public void OnGet()
+ {
+ }
+ }
+}
diff --git a/JoshHeaps.Net/Pages/Index.cshtml b/JoshHeaps.Net/Pages/Index.cshtml
index 4e18a34..465529b 100644
--- a/JoshHeaps.Net/Pages/Index.cshtml
+++ b/JoshHeaps.Net/Pages/Index.cshtml
@@ -1,79 +1,98 @@
@page
@model JoshHeaps.Net.Pages.IndexModel
@{
- ViewData["Title"] = "Home page";
+ ViewData["Title"] = "JoshHeaps.Net";
+ Layout = "_Layout";
}
-
-
-
+
+
+
+
+ @for (int i = 0; i < 64; i++)
+ {
+
+ }
+
+
+
+
+
+Chess Arena
+This page will host your chess UI and interactions.
+
- ./ Projects
- ./ Contact me
-
+
+ ./ Projects
+ ./ Contact me
+
-
+
-
-
-
-
-
-
-
-
- 
-
-
-
-
-
-
- Chess
-- As someone who loves chess, I wanted to create a chess game that I could play with my friends and family. This project is a work in progress, as currently it can only be played locally. It was built in C# on .NET 8.0, using winforms, because I like a challenge. I plan to add online multiplayer functionality in the future. -
-
-
-
-
- Compiler
-- I love solving problems, and figuring out how things work. What better way to do both than writing a compiler myself? This project is a compiler that I wrote in C# on .NET 8.0. It takes in a simple language that I created, outputs the corresponding common intermediate language (CIL), and executes it. I plan to add more features in the future. -
-
-
- 
-
-
-
-
-
-
-
-
-
-
-
-
-
+@ViewData["Title"]
+ @RenderSection("Styles", required: false)
+ @RenderSection("Scripts", required: false)
+
+
+
+
+
+
+
+ @RenderBody()
+
+
+
+
+
\ No newline at end of file
diff --git a/JoshHeaps.Net/Pages/_Layout.cshtml.cs b/JoshHeaps.Net/Pages/_Layout.cshtml.cs
new file mode 100644
index 0000000..b5a6f5d
--- /dev/null
+++ b/JoshHeaps.Net/Pages/_Layout.cshtml.cs
@@ -0,0 +1,12 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace JoshHeaps.Net.Pages
+{
+ public class _LayoutModel : PageModel
+ {
+ public void OnGet()
+ {
+ }
+ }
+}
diff --git a/JoshHeaps.Net/Program.cs b/JoshHeaps.Net/Program.cs
index bc275e4..7a794f5 100644
--- a/JoshHeaps.Net/Program.cs
+++ b/JoshHeaps.Net/Program.cs
@@ -1,8 +1,18 @@
+using JoshHeaps.Net.Hubs;
+using JoshHeaps.Net.Services.Implementations;
+using JoshHeaps.Net.Services.Interfaces;
+
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
+builder.Services.AddControllers();
+
+builder.Services.AddSignalR();
+
+builder.Services.AddSingleton();
+
var app = builder.Build();
// Configure the HTTP request pipeline.
@@ -14,7 +24,16 @@ if (!app.Environment.IsDevelopment())
}
app.UseHttpsRedirection();
-app.UseStaticFiles();
+
+app.UseStaticFiles(new StaticFileOptions
+{
+ OnPrepareResponse = ctx =>
+ {
+ ctx.Context.Response.Headers.Append("Cache-Control", "no-cache, no-store, must-revalidate");
+ ctx.Context.Response.Headers.Append("Pragma", "no-cache");
+ ctx.Context.Response.Headers.Append("Expires", "0");
+ }
+});
app.UseRouting();
@@ -22,4 +41,8 @@ app.UseAuthorization();
app.MapRazorPages();
+app.MapControllers();
+
+app.MapHub("/chessHub");
+
app.Run();
diff --git a/JoshHeaps.Net/Services/Implementations/ChessService.cs b/JoshHeaps.Net/Services/Implementations/ChessService.cs
new file mode 100644
index 0000000..b5b61b1
--- /dev/null
+++ b/JoshHeaps.Net/Services/Implementations/ChessService.cs
@@ -0,0 +1,697 @@
+using JoshHeaps.Net.Models;
+using JoshHeaps.Net.Services.Interfaces;
+
+namespace JoshHeaps.Net.Services.Implementations;
+
+public class ChessService : IChessService
+{
+ public GameState CreateNewGame()
+ {
+ var gameState = new GameState();
+
+ InitializeBoard(gameState);
+
+ return gameState;
+ }
+
+ private void InitializeBoard(GameState gameState)
+ {
+ for (int r = 0; r < 8; r++)
+ for (int c = 0; c < 8; c++)
+ gameState.Board[r, c] = null;
+
+ gameState.Pieces.Clear();
+ gameState.MoveHistory.Clear();
+
+ gameState.WhiteCanCastleKingside = true;
+ gameState.WhiteCanCastleQueenside = true;
+ gameState.BlackCanCastleKingside = true;
+ gameState.BlackCanCastleQueenside = true;
+ gameState.EnPassantTarget = null;
+
+ SetupBlackPieces(gameState);
+ SetupWhitePieces(gameState);
+
+ gameState.CurrentPlayer = PieceColor.White;
+
+ UpdateCheckStatus(gameState);
+ }
+
+ private static void SetupBlackPieces(GameState gs)
+ {
+ var blackMajors = new[]
+ {
+ PieceType.Rook, PieceType.Knight, PieceType.Bishop,
+ PieceType.Queen, PieceType.King, PieceType.Bishop,
+ PieceType.Knight, PieceType.Rook
+ };
+
+ for (int c = 0; c < 8; c++)
+ {
+ var major = new ChessPiece($"b{blackMajors[c]}{c}", blackMajors[c], PieceColor.Black, new Position(0, c));
+ gs.Board[0, c] = major;
+ gs.Pieces.Add(major);
+ }
+
+ for (int c = 0; c < 8; c++)
+ {
+ var pawn = new ChessPiece($"bPawn{c}", PieceType.Pawn, PieceColor.Black, new Position(1, c));
+ gs.Board[1, c] = pawn;
+ gs.Pieces.Add(pawn);
+ }
+ }
+
+ private static void SetupWhitePieces(GameState gs)
+ {
+ var whiteMajors = new[]
+ {
+ PieceType.Rook, PieceType.Knight, PieceType.Bishop,
+ PieceType.Queen, PieceType.King, PieceType.Bishop,
+ PieceType.Knight, PieceType.Rook
+ };
+
+ for (int c = 0; c < 8; c++)
+ {
+ var major = new ChessPiece($"w{whiteMajors[c]}{c}", whiteMajors[c], PieceColor.White, new Position(7, c));
+ gs.Board[7, c] = major;
+ gs.Pieces.Add(major);
+ }
+
+ for (int c = 0; c < 8; c++)
+ {
+ var pawn = new ChessPiece($"wPawn{c}", PieceType.Pawn, PieceColor.White, new Position(6, c));
+ gs.Board[6, c] = pawn;
+ gs.Pieces.Add(pawn);
+ }
+ }
+
+ public List<(ChessPiece piece, List moves)> GetAllLegalMoves(GameState gameState)
+ {
+ var result = new List<(ChessPiece piece, List moves)>();
+
+ var currentPieces = gameState
+ .Pieces
+ .Where(p => p.Color == gameState.CurrentPlayer && p.Position.Row >= 0)
+ .ToList();
+
+ foreach (var piece in currentPieces)
+ {
+ var moves = GetLegalMovesForPiece(gameState, piece.Id);
+
+ if (moves.Count > 0)
+ result.Add((piece, moves));
+ }
+
+ return result;
+ }
+
+ public List GetLegalMovesForPiece(GameState gameState, string pieceId)
+ {
+ var piece = gameState.Pieces.FirstOrDefault(p => p.Id == pieceId);
+
+ if (piece == null) return [];
+ if (piece.Color != gameState.CurrentPlayer) return [];
+
+ var candidateMoves = GenerateCandidateMoves(gameState, piece);
+ var legalMoves = new List();
+
+ foreach (var pos in candidateMoves)
+ if (IsMoveLegalConsideringCheck(gameState, piece, pos))
+ legalMoves.Add(pos);
+
+ return legalMoves;
+ }
+
+ public MoveResultDto MakeMove(GameState gameState, MoveDto moveDto)
+ {
+ var piece = gameState.Pieces.FirstOrDefault(p => p.Id == moveDto.PieceId);
+
+ if (piece == null)
+ return new MoveResultDto { Success = false, Message = "Piece not found." };
+
+ if (piece.Color != gameState.CurrentPlayer)
+ return new MoveResultDto { Success = false, Message = "Not your turn." };
+
+ var legalMoves = GetLegalMovesForPiece(gameState, piece.Id);
+ var targetPos = new Position(moveDto.TargetRow, moveDto.TargetCol);
+
+ if (!legalMoves.Any(m => m.Row == moveDto.TargetRow && m.Col == moveDto.TargetCol))
+ return new MoveResultDto { Success = false, Message = "Illegal move." };
+
+ PerformMove(gameState, piece, targetPos, moveDto);
+
+ UpdateCheckStatus(gameState);
+
+ var notation = $"{piece.Id}:{piece.Position}->{targetPos}";
+ gameState.MoveHistory.Add(notation);
+
+ return new MoveResultDto
+ {
+ Success = true,
+ Message = "Move successful.",
+ IsCheck = gameState.IsCheck,
+ IsCheckmate = gameState.IsCheckmate,
+ IsStalemate = gameState.IsStalemate
+ };
+ }
+
+ private static void PerformMove(GameState gs, ChessPiece piece, Position targetPos, MoveDto moveDto)
+ {
+ var oldPos = piece.Position;
+ var captured = gs.Board[targetPos.Row, targetPos.Col];
+
+ HandleEnPassantIfNeeded(gs, piece, targetPos, ref captured);
+
+ gs.Board[oldPos.Row, oldPos.Col] = null;
+ piece.Position = targetPos;
+ gs.Board[targetPos.Row, targetPos.Col] = piece;
+
+ if (captured != null && captured != piece)
+ captured.Position = new Position(-1, -1);
+
+ bool wasFirstMove = !piece.HasMoved;
+ piece.HasMoved = true;
+
+ HandleCastlingIfNeeded(gs, piece, oldPos, targetPos, wasFirstMove);
+
+ HandlePawnTwoSquareMove(gs, piece, oldPos, targetPos, wasFirstMove);
+
+ HandlePawnPromotionIfNeeded(piece, moveDto);
+
+ UpdateCastlingRights(gs, piece, oldPos);
+
+ gs.CurrentPlayer = gs.CurrentPlayer == PieceColor.White
+ ? PieceColor.Black
+ : PieceColor.White;
+ }
+
+ private static void HandleEnPassantIfNeeded(GameState gs, ChessPiece piece, Position targetPos, ref ChessPiece? captured)
+ {
+ if (piece.Type != PieceType.Pawn || !gs.EnPassantTarget.HasValue)
+ return;
+
+ var enPassantSquare = gs.EnPassantTarget.Value;
+
+ if (targetPos.Row == enPassantSquare.Row && targetPos.Col == enPassantSquare.Col)
+ {
+ int direction = piece.Color == PieceColor.White ? 1 : -1;
+ var capturedPos = new Position(targetPos.Row + direction, targetPos.Col);
+ var potentialPawn = gs.Board[capturedPos.Row, capturedPos.Col];
+
+ if (potentialPawn != null && potentialPawn.Color != piece.Color && potentialPawn.Type == PieceType.Pawn)
+ {
+ gs.Board[capturedPos.Row, capturedPos.Col] = null;
+ potentialPawn.Position = new Position(-1, -1);
+ captured = potentialPawn;
+ }
+ }
+ }
+
+ private static void HandleCastlingIfNeeded(GameState gs, ChessPiece piece, Position oldPos, Position targetPos, bool wasFirstMove)
+ {
+ if (piece.Type != PieceType.King || !wasFirstMove)
+ return;
+
+ var colDiff = targetPos.Col - oldPos.Col;
+
+ if (Math.Abs(colDiff) == 2)
+ {
+ bool isKingside = colDiff > 0;
+ int rookStartCol = isKingside ? 7 : 0;
+ int rookEndCol = isKingside ? 5 : 3;
+ var rook = gs.Board[oldPos.Row, rookStartCol];
+
+ if (rook != null && rook.Type == PieceType.Rook && !rook.HasMoved)
+ {
+ gs.Board[oldPos.Row, rookStartCol] = null;
+ rook.Position = new Position(oldPos.Row, rookEndCol);
+ gs.Board[oldPos.Row, rookEndCol] = rook;
+ rook.HasMoved = true;
+ }
+ }
+ }
+
+ private static void HandlePawnTwoSquareMove(GameState gs, ChessPiece piece, Position oldPos, Position targetPos, bool wasFirstMove)
+ {
+ gs.EnPassantTarget = null;
+
+ if (piece.Type != PieceType.Pawn || !wasFirstMove)
+ return;
+
+ var rowDiff = Math.Abs(targetPos.Row - oldPos.Row);
+
+ if (rowDiff == 2)
+ {
+ var rowBehind = (oldPos.Row + targetPos.Row) / 2;
+ gs.EnPassantTarget = new Position(rowBehind, oldPos.Col);
+ }
+ }
+
+ private static void HandlePawnPromotionIfNeeded(ChessPiece piece, MoveDto moveDto)
+ {
+ if (piece.Type != PieceType.Pawn)
+ return;
+
+ bool promotionRow = piece.Color == PieceColor.White
+ ? piece.Position.Row == 0
+ : piece.Position.Row == 7;
+
+ if (!promotionRow) return;
+
+ var promotionChoice = moveDto.PromotionChoice ?? PieceType.Queen;
+ piece.Type = promotionChoice;
+ }
+
+ private static void UpdateCastlingRights(GameState gs, ChessPiece movedPiece, Position oldPos)
+ {
+ if (movedPiece.Type == PieceType.King)
+ {
+ if (movedPiece.Color == PieceColor.White)
+ {
+ gs.WhiteCanCastleKingside = false;
+ gs.WhiteCanCastleQueenside = false;
+ }
+ else
+ {
+ gs.BlackCanCastleKingside = false;
+ gs.BlackCanCastleQueenside = false;
+ }
+
+ return;
+ }
+
+ if (movedPiece.Type == PieceType.Rook)
+ {
+ if (movedPiece.Color == PieceColor.White)
+ {
+ if (oldPos.Row == 7 && oldPos.Col == 0)
+ gs.WhiteCanCastleQueenside = false;
+
+ if (oldPos.Row == 7 && oldPos.Col == 7)
+ gs.WhiteCanCastleKingside = false;
+ }
+ else
+ {
+ if (oldPos.Row == 0 && oldPos.Col == 0)
+ gs.BlackCanCastleQueenside = false;
+
+ if (oldPos.Row == 0 && oldPos.Col == 7)
+ gs.BlackCanCastleKingside = false;
+ }
+ }
+ }
+
+ private IEnumerable GenerateCandidateMoves(GameState gs, ChessPiece piece)
+ {
+ return piece.Type switch
+ {
+ PieceType.Pawn => GeneratePawnMoves(gs, piece),
+ PieceType.Rook => GenerateRookMoves(gs, piece),
+ PieceType.Knight => GenerateKnightMoves(gs, piece),
+ PieceType.Bishop => GenerateBishopMoves(gs, piece),
+ PieceType.Queen => GenerateQueenMoves(gs, piece),
+ PieceType.King => GenerateKingMoves(gs, piece),
+ _ => []
+ };
+ }
+
+ private bool IsMoveLegalConsideringCheck(GameState gs, ChessPiece piece, Position target)
+ {
+ var clone = CloneGameState(gs);
+ var clonedPiece = clone.Pieces.First(p => p.Id == piece.Id);
+ var oldPos = clonedPiece.Position;
+
+ clone.Board[oldPos.Row, oldPos.Col] = null;
+
+ var captured = clone.Board[target.Row, target.Col];
+
+ if (captured != null) captured.Position = new Position(-1, -1);
+
+ clonedPiece.Position = target;
+ clone.Board[target.Row, target.Col] = clonedPiece;
+
+ HandleEnPassantOnClone(clone, clonedPiece, target);
+
+ HandleCastlingOnClone(clone, clonedPiece, oldPos, target);
+
+ var myKing = clone
+ .Pieces
+ .FirstOrDefault(p => p.Color == piece.Color
+ && p.Type == PieceType.King
+ && p.Position.Row >= 0);
+
+ if (myKing == null) return false;
+
+ bool inCheck = IsSquareAttacked(clone, myKing.Position, myKing.Color);
+
+ return !inCheck;
+ }
+
+ private static void HandleEnPassantOnClone(GameState clone, ChessPiece clonedPiece, Position target)
+ {
+ if (clonedPiece.Type != PieceType.Pawn || !clone.EnPassantTarget.HasValue)
+ return;
+
+ if (target.Row == clone.EnPassantTarget.Value.Row && target.Col == clone.EnPassantTarget.Value.Col)
+ {
+ int direction = clonedPiece.Color == PieceColor.White ? 1 : -1;
+ var capturedPos = new Position(target.Row + direction, target.Col);
+ var epCaptured = clone.Board[capturedPos.Row, capturedPos.Col];
+
+ if (epCaptured != null && epCaptured.Color != clonedPiece.Color && epCaptured.Type == PieceType.Pawn)
+ {
+ clone.Board[capturedPos.Row, capturedPos.Col] = null;
+ epCaptured.Position = new Position(-1, -1);
+ }
+ }
+ }
+
+ private static void HandleCastlingOnClone(GameState clone, ChessPiece clonedPiece, Position oldPos, Position target)
+ {
+ if (clonedPiece.Type != PieceType.King || clonedPiece.HasMoved)
+ return;
+
+ int colDiff = target.Col - oldPos.Col;
+
+ if (Math.Abs(colDiff) == 2)
+ {
+ bool isKingside = colDiff > 0;
+ int rookStartCol = isKingside ? 7 : 0;
+ int rookEndCol = isKingside ? 5 : 3;
+
+ var rook = clone.Board[oldPos.Row, rookStartCol];
+
+ if (rook != null && rook.Type == PieceType.Rook && !rook.HasMoved)
+ {
+ clone.Board[oldPos.Row, rookStartCol] = null;
+ rook.Position = new Position(oldPos.Row, rookEndCol);
+ clone.Board[oldPos.Row, rookEndCol] = rook;
+ }
+ }
+ }
+
+ private bool IsSquareAttacked(GameState gs, Position square, PieceColor colorOfSquare)
+ {
+ var enemyColor = colorOfSquare == PieceColor.White ? PieceColor.Black : PieceColor.White;
+
+ var enemyPieces = gs
+ .Pieces
+ .Where(p => p.Color == enemyColor && p.Position.Row >= 0)
+ .ToList();
+
+ foreach (var enemy in enemyPieces)
+ {
+ var moves = GenerateCandidateMoves(gs, enemy);
+
+ if (moves.Any(m => m.Row == square.Row && m.Col == square.Col))
+ return true;
+ }
+
+ return false;
+ }
+
+ private void UpdateCheckStatus(GameState gs)
+ {
+ gs.IsCheck = false;
+ gs.IsCheckmate = false;
+ gs.IsStalemate = false;
+
+ var king = gs
+ .Pieces
+ .FirstOrDefault(p => p.Color == gs.CurrentPlayer
+ && p.Type == PieceType.King
+ && p.Position.Row >= 0);
+
+ // If there's no king, that's effectively checkmate for that side.
+ if (king == null)
+ {
+ gs.IsCheck = true;
+ gs.IsCheckmate = true;
+ return;
+ }
+
+ bool inCheck = IsSquareAttacked(gs, king.Position, gs.CurrentPlayer);
+
+ gs.IsCheck = inCheck;
+
+ var allMoves = GetAllLegalMoves(gs);
+
+ if (allMoves.Count == 0 && inCheck)
+ {
+ gs.IsCheckmate = true;
+
+ return;
+ }
+
+ if (allMoves.Count == 0 && !inCheck)
+ {
+ gs.IsStalemate = true;
+
+ return;
+ }
+ }
+
+ private static GameState CloneGameState(GameState original)
+ {
+ var clone = new GameState
+ {
+ GameId = original.GameId,
+ CurrentPlayer = original.CurrentPlayer,
+ EnPassantTarget = original.EnPassantTarget,
+ WhiteCanCastleKingside = original.WhiteCanCastleKingside,
+ WhiteCanCastleQueenside = original.WhiteCanCastleQueenside,
+ BlackCanCastleKingside = original.BlackCanCastleKingside,
+ BlackCanCastleQueenside = original.BlackCanCastleQueenside,
+ MoveHistory = new List(original.MoveHistory),
+ Board = new ChessPiece[8,8],
+ };
+
+ foreach (var p in original.Pieces)
+ {
+ var copy = new ChessPiece(p.Id, p.Type, p.Color, p.Position)
+ {
+ HasMoved = p.HasMoved
+ };
+
+ clone.Pieces.Add(copy);
+ }
+
+ foreach (var cp in clone.Pieces)
+ if (cp.Position.Row >= 0)
+ clone.Board[cp.Position.Row, cp.Position.Col] = cp;
+
+ return clone;
+ }
+
+ private static List GeneratePawnMoves(GameState gs, ChessPiece piece)
+ {
+ var moves = new List();
+ int direction = piece.Color == PieceColor.White ? -1 : 1;
+ var startRow = piece.Position.Row;
+ var startCol = piece.Position.Col;
+
+ var forward1 = startRow + direction;
+
+ if (IsOnBoard(forward1, startCol) && gs.Board[forward1, startCol] == null)
+ {
+ moves.Add(new Position(forward1, startCol));
+
+ if (!piece.HasMoved)
+ {
+ var forward2 = startRow + 2 * direction;
+
+ if (IsOnBoard(forward2, startCol) && gs.Board[forward2, startCol] == null)
+ moves.Add(new Position(forward2, startCol));
+ }
+ }
+
+ var leftCol = startCol - 1;
+ var rightCol = startCol + 1;
+
+ if (IsOnBoard(forward1, leftCol))
+ {
+ var occupant = gs.Board[forward1, leftCol];
+
+ if (occupant != null && occupant.Color != piece.Color)
+ moves.Add(new Position(forward1, leftCol));
+ }
+
+ if (IsOnBoard(forward1, rightCol))
+ {
+ var occupant = gs.Board[forward1, rightCol];
+
+ if (occupant != null && occupant.Color != piece.Color)
+ moves.Add(new Position(forward1, rightCol));
+ }
+
+ if (gs.EnPassantTarget.HasValue)
+ {
+ var ep = gs.EnPassantTarget.Value;
+
+ if (ep.Row == forward1 && Math.Abs(ep.Col - startCol) == 1)
+ moves.Add(ep);
+ }
+
+ return moves;
+ }
+
+ private static List GenerateRookMoves(GameState gs, ChessPiece piece)
+ => GenerateSlidingMoves(gs, piece, [(1, 0), (-1, 0), (0, 1), (0, -1)]);
+
+ private static List GenerateBishopMoves(GameState gs, ChessPiece piece)
+ => GenerateSlidingMoves(gs, piece, [(1, 1), (1, -1), (-1, 1), (-1, -1)]);
+
+ private static List GenerateQueenMoves(GameState gs, ChessPiece piece)
+ => GenerateSlidingMoves(gs, piece,
+ [
+ (1, 0), (-1, 0), (0, 1), (0, -1),
+ (1, 1), (1, -1), (-1, 1), (-1, -1)
+ ]);
+
+ private static List GenerateSlidingMoves(GameState gs, ChessPiece piece, (int dr, int dc)[] directions)
+ {
+ var results = new List();
+ var (startRow, startCol) = piece.Position;
+
+ foreach (var (dr, dc) in directions)
+ results.AddRange(GetSlidingMovesInDirection(gs, piece, startRow, startCol, dr, dc));
+
+ return results;
+ }
+
+ private static List GetSlidingMovesInDirection(
+ GameState gs,
+ ChessPiece piece,
+ int row,
+ int col,
+ int dr,
+ int dc)
+ {
+ var moves = new List();
+ var r = row;
+ var c = col;
+
+ while (true)
+ {
+ r += dr;
+ c += dc;
+
+ if (!IsOnBoard(r, c))
+ return moves;
+
+ var occupant = gs.Board[r, c];
+
+ if (occupant == null)
+ {
+ moves.Add(new Position(r, c));
+ continue;
+ }
+
+ if (occupant.Color != piece.Color)
+ moves.Add(new Position(r, c));
+
+ return moves;
+ }
+ }
+
+ private static IEnumerable GenerateKnightMoves(GameState gs, ChessPiece piece)
+ {
+ var offsets = new (int, int)[]
+ {
+ (2,1), (2,-1), (-2,1), (-2,-1),
+ (1,2), (1,-2), (-1,2), (-1,-2)
+ };
+
+ foreach (var (dr, dc) in offsets)
+ {
+ var r = piece.Position.Row + dr;
+ var c = piece.Position.Col + dc;
+
+ if (!IsOnBoard(r, c))
+ continue;
+
+ var occupant = gs.Board[r, c];
+
+ if (occupant == null || occupant.Color != piece.Color)
+ yield return new Position(r, c);
+ }
+ }
+
+ private List GenerateKingMoves(GameState gs, ChessPiece piece)
+ {
+ var results = new List();
+ var offsets = new[]
+ {
+ (1,0), (-1,0), (0,1), (0,-1),
+ (1,1), (1,-1), (-1,1), (-1,-1)
+ };
+
+ foreach (var (dr, dc) in offsets)
+ {
+ int r = piece.Position.Row + dr;
+ int c = piece.Position.Col + dc;
+
+ if (!IsOnBoard(r, c))
+ continue;
+
+ var occupant = gs.Board[r, c];
+
+ if (occupant == null || occupant.Color != piece.Color)
+ results.Add(new Position(r, c));
+ }
+
+ if (!piece.HasMoved && !gs.IsCheck && piece.Color == gs.CurrentPlayer)
+ AddCastlingMoves(gs, piece, results);
+
+ return results;
+ }
+
+ private void AddCastlingMoves(GameState gs, ChessPiece king, List results)
+ {
+ bool hasKingsideRight = king.Color == PieceColor.White
+ ? gs.WhiteCanCastleKingside
+ : gs.BlackCanCastleKingside;
+
+ bool hasQueensideRight = king.Color == PieceColor.White
+ ? gs.WhiteCanCastleQueenside
+ : gs.BlackCanCastleQueenside;
+
+ var row = king.Position.Row;
+ var col = king.Position.Col;
+
+ bool areKingsideCastleSpacesEmpty = IsEmpty(row, col + 1, gs)
+ && IsEmpty(row, col + 2, gs);
+
+ bool isKingsideCastleSafe = !IsSquareAttacked(gs, new Position(row, col + 1), king.Color)
+ && !IsSquareAttacked(gs, new Position(row, col + 2), king.Color);
+
+ bool areQueensideCastleSpacesEmpty = IsEmpty(row, col - 1, gs)
+ && IsEmpty(row, col - 2, gs)
+ && IsEmpty(row, col - 3, gs);
+
+ bool isQueensideCastleSafe = !IsSquareAttacked(gs, new Position(row, col - 1), king.Color)
+ && !IsSquareAttacked(gs, new Position(row, col - 2), king.Color);
+
+ bool canCastleKingside = areKingsideCastleSpacesEmpty
+ && isKingsideCastleSafe
+ && hasKingsideRight;
+
+ bool canCastleQueenside = areQueensideCastleSpacesEmpty
+ && isQueensideCastleSafe
+ && hasQueensideRight;
+
+ if (canCastleKingside) results.Add(new Position(row, col + 2));
+
+ if (canCastleQueenside) results.Add(new Position(row, col - 2));
+ }
+
+ private static bool IsEmpty(int r, int c, GameState gs)
+ {
+ if (!IsOnBoard(r, c)) return false;
+
+ return gs.Board[r, c] == null;
+ }
+
+ private static bool IsOnBoard(int r, int c)
+ => r >= 0 && r < 8 && c >= 0 && c < 8;
+}
diff --git a/JoshHeaps.Net/Services/Interfaces/IChessService.cs b/JoshHeaps.Net/Services/Interfaces/IChessService.cs
new file mode 100644
index 0000000..3c440c1
--- /dev/null
+++ b/JoshHeaps.Net/Services/Interfaces/IChessService.cs
@@ -0,0 +1,11 @@
+using JoshHeaps.Net.Models;
+
+namespace JoshHeaps.Net.Services.Interfaces;
+
+public interface IChessService
+{
+ GameState CreateNewGame();
+ List<(ChessPiece piece, List moves)> GetAllLegalMoves(GameState gameState);
+ List GetLegalMovesForPiece(GameState gameState, string pieceId);
+ MoveResultDto MakeMove(GameState gameState, MoveDto moveDto);
+}
diff --git a/JoshHeaps.Net/wwwroot/css/chess/game.css b/JoshHeaps.Net/wwwroot/css/chess/game.css
new file mode 100644
index 0000000..e22f2ad
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/css/chess/game.css
@@ -0,0 +1,40 @@
+#chessBoard {
+ margin: 2vw auto;
+ width: 60vw;
+ height: 60vw;
+ display: grid;
+ grid-template-columns: repeat(8, 1fr);
+ grid-template-rows: repeat(8, 1fr);
+ border: 0px;
+}
+
+.chessSquare {
+ background-color: inherit;
+ position: relative;
+}
+
+.chessSquare.light {
+ background-color: #ccc;
+}
+
+.chessSquare.dark {
+ background-color: #656770;
+}
+
+.chessPiece {
+ width: 90%;
+ height: 90%;
+ display: block;
+ margin: auto;
+}
+
+.chessSquare.selected {
+ border: 4px solid red;
+ box-sizing: border-box;
+}
+
+.chessSquare.legal {
+ border: 4px dashed red;
+ box-sizing: border-box;
+ cursor: pointer;
+}
\ No newline at end of file
diff --git a/JoshHeaps.Net/wwwroot/css/chess/site.css b/JoshHeaps.Net/wwwroot/css/chess/site.css
new file mode 100644
index 0000000..b99e705
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/css/chess/site.css
@@ -0,0 +1,106 @@
+html, body {
+ background-color: #2b2c30;
+ color: #d6d6d6;
+ cursor: default;
+ height: 100%;
+ margin: 0;
+}
+
+#startGameBtn {
+ background-color: #8cd5ed;
+ color: #262626;
+ border-radius: 30px;
+ border: 0px;
+ cursor: pointer;
+ order: 1;
+}
+
+#chessContainer {
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ justify-content: space-evenly;
+ height: 100vh;
+ box-sizing: border-box;
+ padding: 5vw;
+}
+
+#chessBoard {
+ aspect-ratio: 1 / 1;
+ width: 90vw; /* use the smaller of width or height */
+ height: auto;
+ max-height: 90vw;
+}
+
+#boardContainer {
+ align-content: center;
+ flex-grow: 1;
+}
+
+.sideContent {
+ display: flex;
+ flex-direction: column;
+ align-content: center;
+ justify-content: center;
+ text-align: center;
+}
+
+#textContainer {
+ flex-direction: column;
+ order: -1;
+ flex-shrink: 1;
+}
+
+#buttonContainer {
+ flex-grow: 3;
+}
+
+/* Put UI to left/right when screen is short */
+@media (min-aspect-ratio: 1/1) {
+ #chessContainer {
+ display: grid;
+ grid-template-columns: auto, auto;
+ grid-template-rows: auto, auto;
+ align-items: center;
+ flex-direction: row;
+ justify-content: center;
+ align-items: center;
+ height: 100vh;
+ padding: 0;
+ }
+
+ .sideContent {
+ display: flex;
+ flex-direction: column;
+ flex-grow: 1;
+ flex-shrink: 0;
+ align-items: center;
+ text-align: center;
+ padding: min(5vw, 5vh);
+ }
+
+ #boardContainer {
+ grid-row: 1 / span 2;
+ grid-column: 1;
+ }
+
+ #textContainer {
+ grid-row: 1;
+ grid-column: 2;
+ text-align: center;
+ }
+
+ #buttonContainer {
+ grid-row: 2;
+ grid-column: 2;
+ text-align: left;
+ align-self: start;
+ }
+
+ #chessBoard {
+ aspect-ratio: 1 / 1;
+ flex-shrink: 1;
+ width: min(90vh, 90vw);
+ max-height: 90vh;
+ }
+}
\ No newline at end of file
diff --git a/JoshHeaps.Net/wwwroot/css/footer.css b/JoshHeaps.Net/wwwroot/css/home/footer.css
similarity index 100%
rename from JoshHeaps.Net/wwwroot/css/footer.css
rename to JoshHeaps.Net/wwwroot/css/home/footer.css
diff --git a/JoshHeaps.Net/wwwroot/css/imageLeftProject.css b/JoshHeaps.Net/wwwroot/css/home/imageLeftProject.css
similarity index 100%
rename from JoshHeaps.Net/wwwroot/css/imageLeftProject.css
rename to JoshHeaps.Net/wwwroot/css/home/imageLeftProject.css
diff --git a/JoshHeaps.Net/wwwroot/css/imageRightProject.css b/JoshHeaps.Net/wwwroot/css/home/imageRightProject.css
similarity index 100%
rename from JoshHeaps.Net/wwwroot/css/imageRightProject.css
rename to JoshHeaps.Net/wwwroot/css/home/imageRightProject.css
diff --git a/JoshHeaps.Net/wwwroot/css/project.css b/JoshHeaps.Net/wwwroot/css/home/project.css
similarity index 100%
rename from JoshHeaps.Net/wwwroot/css/project.css
rename to JoshHeaps.Net/wwwroot/css/home/project.css
diff --git a/JoshHeaps.Net/wwwroot/css/site.css b/JoshHeaps.Net/wwwroot/css/home/site.css
similarity index 100%
rename from JoshHeaps.Net/wwwroot/css/site.css
rename to JoshHeaps.Net/wwwroot/css/home/site.css
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/BlackBishop.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackBishop.svg
new file mode 100644
index 0000000..e88c406
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackBishop.svg
@@ -0,0 +1,12 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/BlackKing.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackKing.svg
new file mode 100644
index 0000000..ba2ac9f
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackKing.svg
@@ -0,0 +1,12 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/BlackKnight.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackKnight.svg
new file mode 100644
index 0000000..04541a8
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackKnight.svg
@@ -0,0 +1,22 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/BlackPawn.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackPawn.svg
new file mode 100644
index 0000000..b534de8
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackPawn.svg
@@ -0,0 +1,5 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/BlackQueen.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackQueen.svg
new file mode 100644
index 0000000..e557734
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackQueen.svg
@@ -0,0 +1,27 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/BlackRook.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackRook.svg
new file mode 100644
index 0000000..4eec43c
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/BlackRook.svg
@@ -0,0 +1,39 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteBishop.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteBishop.svg
new file mode 100644
index 0000000..3a8eaa2
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteBishop.svg
@@ -0,0 +1,12 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteKing.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteKing.svg
new file mode 100644
index 0000000..632ca1a
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteKing.svg
@@ -0,0 +1,9 @@
+
+
\ No newline at end of file
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteKnight.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteKnight.svg
new file mode 100644
index 0000000..a5f31c6
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteKnight.svg
@@ -0,0 +1,19 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/WhitePawn.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/WhitePawn.svg
new file mode 100644
index 0000000..b265fe1
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/WhitePawn.svg
@@ -0,0 +1,5 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteQueen.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteQueen.svg
new file mode 100644
index 0000000..8df7c8f
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteQueen.svg
@@ -0,0 +1,15 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteRook.svg b/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteRook.svg
new file mode 100644
index 0000000..0574ca6
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/images/Chess Images/WhiteRook.svg
@@ -0,0 +1,25 @@
+
+
+
diff --git a/JoshHeaps.Net/wwwroot/js/ChessScripts/chessLogic.js b/JoshHeaps.Net/wwwroot/js/ChessScripts/chessLogic.js
new file mode 100644
index 0000000..baabee8
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/js/ChessScripts/chessLogic.js
@@ -0,0 +1,219 @@
+let currentGameId = null;
+let currentPlayerId = null;
+let signalRConnection = null;
+let selectedPiece = null;
+let legalMoves = [];
+
+async function startNewGame() {
+ // Stop previous SignalR connection if needed
+ if (signalRConnection) {
+ await signalRConnection.stop();
+ signalRConnection = null;
+ }
+
+ // Join the game via API
+ const response = await fetch('/api/chess/JoinGame');
+ const gameData = await response.json();
+
+ currentGameId = gameData.gameId;
+ currentPlayerId = gameData.id;
+ console.log("🆕 Game started:", currentGameId);
+
+ // Build and start SignalR connection
+ signalRConnection = new signalR.HubConnectionBuilder()
+ .withUrl("/chessHub")
+ .configureLogging(signalR.LogLevel.Information)
+ .build();
+
+ signalRConnection.onclose(err => {
+ console.error("❌ SignalR connection closed:", err?.message);
+ });
+
+ signalRConnection.on("ReceiveMoveUpdate", async (gameId, moveResultDto) => {
+ if (gameId !== currentGameId) return;
+
+ const res = await fetch(`/api/chess/${gameId}`);
+ const data = await res.json();
+ renderPieces(data.pieces);
+
+ alertGameStatusChange(moveResultDto);
+ });
+
+ try {
+ await signalRConnection.start();
+ console.log("✅ SignalR connected");
+ await signalRConnection.invoke("JoinWebsocketGroup", currentGameId);
+ } catch (err) {
+ console.error("❌ SignalR failed to start or join:", err);
+ }
+
+ // Render initial state
+ const gameState = await fetch(`/api/chess/${currentGameId}`);
+ const data = await gameState.json();
+ renderPieces(data.pieces);
+}
+
+function renderPieces(pieces) {
+ // Clear all squares
+ for (let i = 0; i < 64; i++) {
+ const square = document.getElementById(`square-${i}`);
+ square.innerHTML = ""; // Remove any previous images
+ }
+
+ // Place each piece
+ pieces.forEach(piece => {
+ const index = piece.row * 8 + piece.col;
+ const square = document.getElementById(`square-${index}`);
+ if (!square) return;
+
+ const img = document.createElement("img");
+ img.src = getPieceImageUrl(piece);
+ img.alt = piece.type;
+ img.classList.add("chessPiece");
+
+ img.onclick = (e) => {
+ e.stopPropagation(); // 👈 Prevents the parent square click from firing
+ handlePieceClick(piece);
+ console.log("Clicked on:", piece);
+ };
+
+ square.appendChild(img);
+ });
+
+ for (let i = 0; i < 64; i++) {
+ const square = document.getElementById(`square-${i}`);
+
+ if (!square.classList.contains("legal")) {
+ square.onclick = () => clearHighlights();
+ }
+ }
+}
+
+function getPieceImageUrl(piece) {
+ const basePath = "/images/Chess Images/";
+ const color = piece.color === 0 ? "White" : "Black"; // Or use "White"/"Black" if string
+ const typeMap = {
+ 0: "Pawn",
+ 1: "Rook",
+ 2: "Knight",
+ 3: "Bishop",
+ 4: "Queen",
+ 5: "King"
+ };
+
+ return basePath + color + typeMap[piece.type] + ".svg";
+}
+
+async function handlePieceClick(piece) {
+ clearHighlights();
+
+ selectedPiece = piece;
+
+ try {
+ const res = await fetch(`/api/chess/${currentGameId}/legalMoves/${piece.id}`);
+ if (!res.ok) throw new Error("API failed");
+
+ legalMoves = await res.json();
+ highlightSelected(piece.row, piece.col);
+ highlightLegalMoves(legalMoves);
+ } catch (err) {
+ console.error("Error in handlePieceClick:", err);
+ }
+}
+
+function highlightSelected(row, col) {
+ document.getElementById(`square-${row * 8 + col}`).classList.add("selected");
+}
+
+function highlightLegalMoves(moves) {
+ moves.forEach(move => {
+ const index = move.row * 8 + move.col;
+ const square = document.getElementById(`square-${index}`);
+ square.classList.add("legal");
+
+ // Remove click from piece (if present) so square click handles it
+ const img = square.querySelector("img");
+ if (img) img.onclick = null;
+
+ // Let the square itself handle the move
+ square.onclick = () => handleMove(move.row, move.col);
+ });
+}
+
+async function handleMove(targetRow, targetCol) {
+ if (!selectedPiece) return;
+
+ const moveDto = {
+ GameId: currentGameId,
+ PlayerId: currentPlayerId,
+ PieceId: selectedPiece.id,
+ SourceRow: selectedPiece.row,
+ SourceCol: selectedPiece.col,
+ TargetRow: targetRow,
+ TargetCol: targetCol,
+ PromotionChoice: null // optional
+ };
+
+ const res = await fetch("/api/chess/move", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(moveDto)
+ });
+
+ const moveResultDto = await res.json();
+
+ if (!res.ok || !moveResultDto.success) {
+ alert("❌ " + (moveResultDto.message || "Invalid move or not your turn."));
+ return;
+ }
+
+ const updatedGame = await fetch(`/api/chess/${currentGameId}`).then(r => r.json());
+ renderPieces(updatedGame.pieces);
+
+ // Reset state
+ selectedPiece = null;
+ legalMoves = [];
+ clearHighlights();
+ await signalRConnection.invoke("MoveMade", currentGameId, moveResultDto);
+
+ alertGameStatusChange(moveResultDto);
+}
+
+function clearHighlights() {
+ for (let i = 0; i < 64; i++) {
+ const square = document.getElementById(`square-${i}`);
+
+ // Remove legal move markers and their onclicks
+ if (square.classList.contains("legal")) {
+ square.classList.remove("legal");
+ square.onclick = null;
+ }
+
+ // Always remove selection styling
+ square.classList.remove("selected");
+ }
+
+ selectedPiece = null;
+ legalMoves = [];
+}
+
+function alertGameStatusChange(moveResultDto) {
+ setTimeout(() => {
+ // 🟡 Optional: show check
+ if (moveResultDto.isCheck) {
+ console.log("🛑 Check!");
+ }
+
+ // ✅ Handle game end
+ if (moveResultDto.isCheckmate) {
+ alert("♟️ Checkmate!");
+ gameOver = true;
+ } else if (moveResultDto.isStalemate) {
+ alert("🤝 Stalemate!");
+ gameOver = true;
+ }
+ }, 500);
+}
+
+console.log("chessLogic.js loaded");
+window.startNewGame = startNewGame;
\ No newline at end of file
diff --git a/JoshHeaps.Net/wwwroot/js/signalr/signalr.min.js b/JoshHeaps.Net/wwwroot/js/signalr/signalr.min.js
new file mode 100644
index 0000000..d168d80
--- /dev/null
+++ b/JoshHeaps.Net/wwwroot/js/signalr/signalr.min.js
@@ -0,0 +1,2 @@
+var t, e; t = self, e = () => (() => { var t = { d: (e, s) => { for (var i in s) t.o(s, i) && !t.o(e, i) && Object.defineProperty(e, i, { enumerable: !0, get: s[i] }) } }; t.g = function () { if ("object" == typeof globalThis) return globalThis; try { return this || new Function("return this")() } catch (t) { if ("object" == typeof window) return window } }(), t.o = (t, e) => Object.prototype.hasOwnProperty.call(t, e), t.r = t => { "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(t, "t", { value: !0 }) }; var e, s = {}; t.r(s), t.d(s, { AbortError: () => r, DefaultHttpClient: () => H, HttpClient: () => d, HttpError: () => i, HttpResponse: () => u, HttpTransportType: () => F, HubConnection: () => q, HubConnectionBuilder: () => tt, HubConnectionState: () => A, JsonHubProtocol: () => Y, LogLevel: () => e, MessageType: () => x, NullLogger: () => f, Subject: () => U, TimeoutError: () => n, TransferFormat: () => B, VERSION: () => p }); class i extends Error { constructor(t, e) { const s = new.target.prototype; super(`${t}: Status code '${e}'`), this.statusCode = e, this.__proto__ = s } } class n extends Error { constructor(t = "A timeout occurred.") { const e = new.target.prototype; super(t), this.__proto__ = e } } class r extends Error { constructor(t = "An abort occurred.") { const e = new.target.prototype; super(t), this.__proto__ = e } } class o extends Error { constructor(t, e) { const s = new.target.prototype; super(t), this.transport = e, this.errorType = "UnsupportedTransportError", this.__proto__ = s } } class h extends Error { constructor(t, e) { const s = new.target.prototype; super(t), this.transport = e, this.errorType = "DisabledTransportError", this.__proto__ = s } } class c extends Error { constructor(t, e) { const s = new.target.prototype; super(t), this.transport = e, this.errorType = "FailedToStartTransportError", this.__proto__ = s } } class a extends Error { constructor(t) { const e = new.target.prototype; super(t), this.errorType = "FailedToNegotiateWithServerError", this.__proto__ = e } } class l extends Error { constructor(t, e) { const s = new.target.prototype; super(t), this.innerErrors = e, this.__proto__ = s } } class u { constructor(t, e, s) { this.statusCode = t, this.statusText = e, this.content = s } } class d { get(t, e) { return this.send({ ...e, method: "GET", url: t }) } post(t, e) { return this.send({ ...e, method: "POST", url: t }) } delete(t, e) { return this.send({ ...e, method: "DELETE", url: t }) } getCookieString(t) { return "" } } !function (t) { t[t.Trace = 0] = "Trace", t[t.Debug = 1] = "Debug", t[t.Information = 2] = "Information", t[t.Warning = 3] = "Warning", t[t.Error = 4] = "Error", t[t.Critical = 5] = "Critical", t[t.None = 6] = "None" }(e || (e = {})); class f { constructor() { } log(t, e) { } } f.instance = new f; const p = "8.0.7"; class w { static isRequired(t, e) { if (null == t) throw new Error(`The '${e}' argument is required.`) } static isNotEmpty(t, e) { if (!t || t.match(/^\s*$/)) throw new Error(`The '${e}' argument should not be empty.`) } static isIn(t, e, s) { if (!(t in e)) throw new Error(`Unknown ${s} value: ${t}.`) } } class g { static get isBrowser() { return !g.isNode && "object" == typeof window && "object" == typeof window.document } static get isWebWorker() { return !g.isNode && "object" == typeof self && "importScripts" in self } static get isReactNative() { return !g.isNode && "object" == typeof window && void 0 === window.document } static get isNode() { return "undefined" != typeof process && process.release && "node" === process.release.name } } function m(t, e) { let s = ""; return y(t) ? (s = `Binary data of length ${t.byteLength}`, e && (s += `. Content: '${function (t) { const e = new Uint8Array(t); let s = ""; return e.forEach((t => { s += `0x${t < 16 ? "0" : ""}${t.toString(16)} ` })), s.substr(0, s.length - 1) }(t)}'`)) : "string" == typeof t && (s = `String data of length ${t.length}`, e && (s += `. Content: '${t}'`)), s } function y(t) { return t && "undefined" != typeof ArrayBuffer && (t instanceof ArrayBuffer || t.constructor && "ArrayBuffer" === t.constructor.name) } async function b(t, s, i, n, r, o) { const h = {}, [c, a] = $(); h[c] = a, t.log(e.Trace, `(${s} transport) sending data. ${m(r, o.logMessageContent)}.`); const l = y(r) ? "arraybuffer" : "text", u = await i.post(n, { content: r, headers: { ...h, ...o.headers }, responseType: l, timeout: o.timeout, withCredentials: o.withCredentials }); t.log(e.Trace, `(${s} transport) request complete. Response status: ${u.statusCode}.`) } class v { constructor(t, e) { this.i = t, this.h = e } dispose() { const t = this.i.observers.indexOf(this.h); t > -1 && this.i.observers.splice(t, 1), 0 === this.i.observers.length && this.i.cancelCallback && this.i.cancelCallback().catch((t => { })) } } class E { constructor(t) { this.l = t, this.out = console } log(t, s) { if (t >= this.l) { const i = `[${(new Date).toISOString()}] ${e[t]}: ${s}`; switch (t) { case e.Critical: case e.Error: this.out.error(i); break; case e.Warning: this.out.warn(i); break; case e.Information: this.out.info(i); break; default: this.out.log(i) } } } } function $() { let t = "X-SignalR-User-Agent"; return g.isNode && (t = "User-Agent"), [t, C(p, S(), g.isNode ? "NodeJS" : "Browser", k())] } function C(t, e, s, i) { let n = "Microsoft SignalR/"; const r = t.split("."); return n += `${r[0]}.${r[1]}`, n += ` (${t}; `, n += e && "" !== e ? `${e}; ` : "Unknown OS; ", n += `${s}`, n += i ? `; ${i}` : "; Unknown Runtime Version", n += ")", n } function S() { if (!g.isNode) return ""; switch (process.platform) { case "win32": return "Windows NT"; case "darwin": return "macOS"; case "linux": return "Linux"; default: return process.platform } } function k() { if (g.isNode) return process.versions.node } function P(t) { return t.stack ? t.stack : t.message ? t.message : `${t}` } class T extends d { constructor(e) { if (super(), this.u = e, "undefined" == typeof fetch || g.isNode) { const t = require; this.p = new (t("tough-cookie").CookieJar), "undefined" == typeof fetch ? this.m = t("node-fetch") : this.m = fetch, this.m = t("fetch-cookie")(this.m, this.p) } else this.m = fetch.bind(function () { if ("undefined" != typeof globalThis) return globalThis; if ("undefined" != typeof self) return self; if ("undefined" != typeof window) return window; if (void 0 !== t.g) return t.g; throw new Error("could not find global") }()); if ("undefined" == typeof AbortController) { const t = require; this.v = t("abort-controller") } else this.v = AbortController } async send(t) { if (t.abortSignal && t.abortSignal.aborted) throw new r; if (!t.method) throw new Error("No method defined."); if (!t.url) throw new Error("No url defined."); const s = new this.v; let o; t.abortSignal && (t.abortSignal.onabort = () => { s.abort(), o = new r }); let h, c = null; if (t.timeout) { const i = t.timeout; c = setTimeout((() => { s.abort(), this.u.log(e.Warning, "Timeout from HTTP request."), o = new n }), i) } "" === t.content && (t.content = void 0), t.content && (t.headers = t.headers || {}, y(t.content) ? t.headers["Content-Type"] = "application/octet-stream" : t.headers["Content-Type"] = "text/plain;charset=UTF-8"); try { h = await this.m(t.url, { body: t.content, cache: "no-cache", credentials: !0 === t.withCredentials ? "include" : "same-origin", headers: { "X-Requested-With": "XMLHttpRequest", ...t.headers }, method: t.method, mode: "cors", redirect: "follow", signal: s.signal }) } catch (t) { if (o) throw o; throw this.u.log(e.Warning, `Error from HTTP request. ${t}.`), t } finally { c && clearTimeout(c), t.abortSignal && (t.abortSignal.onabort = null) } if (!h.ok) { const t = await I(h, "text"); throw new i(t || h.statusText, h.status) } const a = I(h, t.responseType), l = await a; return new u(h.status, h.statusText, l) } getCookieString(t) { let e = ""; return g.isNode && this.p && this.p.getCookies(t, ((t, s) => e = s.join("; "))), e } } function I(t, e) { let s; switch (e) { case "arraybuffer": s = t.arrayBuffer(); break; case "text": default: s = t.text(); break; case "blob": case "document": case "json": throw new Error(`${e} is not supported.`) }return s } class _ extends d { constructor(t) { super(), this.u = t } send(t) { return t.abortSignal && t.abortSignal.aborted ? Promise.reject(new r) : t.method ? t.url ? new Promise(((s, o) => { const h = new XMLHttpRequest; h.open(t.method, t.url, !0), h.withCredentials = void 0 === t.withCredentials || t.withCredentials, h.setRequestHeader("X-Requested-With", "XMLHttpRequest"), "" === t.content && (t.content = void 0), t.content && (y(t.content) ? h.setRequestHeader("Content-Type", "application/octet-stream") : h.setRequestHeader("Content-Type", "text/plain;charset=UTF-8")); const c = t.headers; c && Object.keys(c).forEach((t => { h.setRequestHeader(t, c[t]) })), t.responseType && (h.responseType = t.responseType), t.abortSignal && (t.abortSignal.onabort = () => { h.abort(), o(new r) }), t.timeout && (h.timeout = t.timeout), h.onload = () => { t.abortSignal && (t.abortSignal.onabort = null), h.status >= 200 && h.status < 300 ? s(new u(h.status, h.statusText, h.response || h.responseText)) : o(new i(h.response || h.responseText || h.statusText, h.status)) }, h.onerror = () => { this.u.log(e.Warning, `Error from HTTP request. ${h.status}: ${h.statusText}.`), o(new i(h.statusText, h.status)) }, h.ontimeout = () => { this.u.log(e.Warning, "Timeout from HTTP request."), o(new n) }, h.send(t.content) })) : Promise.reject(new Error("No url defined.")) : Promise.reject(new Error("No method defined.")) } } class H extends d { constructor(t) { if (super(), "undefined" != typeof fetch || g.isNode) this.$ = new T(t); else { if ("undefined" == typeof XMLHttpRequest) throw new Error("No usable HttpClient found."); this.$ = new _(t) } } send(t) { return t.abortSignal && t.abortSignal.aborted ? Promise.reject(new r) : t.method ? t.url ? this.$.send(t) : Promise.reject(new Error("No url defined.")) : Promise.reject(new Error("No method defined.")) } getCookieString(t) { return this.$.getCookieString(t) } } class D { static write(t) { return `${t}${D.RecordSeparator}` } static parse(t) { if (t[t.length - 1] !== D.RecordSeparator) throw new Error("Message is incomplete."); const e = t.split(D.RecordSeparator); return e.pop(), e } } D.RecordSeparatorCode = 30, D.RecordSeparator = String.fromCharCode(D.RecordSeparatorCode); class R { writeHandshakeRequest(t) { return D.write(JSON.stringify(t)) } parseHandshakeResponse(t) { let e, s; if (y(t)) { const i = new Uint8Array(t), n = i.indexOf(D.RecordSeparatorCode); if (-1 === n) throw new Error("Message is incomplete."); const r = n + 1; e = String.fromCharCode.apply(null, Array.prototype.slice.call(i.slice(0, r))), s = i.byteLength > r ? i.slice(r).buffer : null } else { const i = t, n = i.indexOf(D.RecordSeparator); if (-1 === n) throw new Error("Message is incomplete."); const r = n + 1; e = i.substring(0, r), s = i.length > r ? i.substring(r) : null } const i = D.parse(e), n = JSON.parse(i[0]); if (n.type) throw new Error("Expected a handshake response from the server."); return [s, n] } } var x, A; !function (t) { t[t.Invocation = 1] = "Invocation", t[t.StreamItem = 2] = "StreamItem", t[t.Completion = 3] = "Completion", t[t.StreamInvocation = 4] = "StreamInvocation", t[t.CancelInvocation = 5] = "CancelInvocation", t[t.Ping = 6] = "Ping", t[t.Close = 7] = "Close", t[t.Ack = 8] = "Ack", t[t.Sequence = 9] = "Sequence" }(x || (x = {})); class U { constructor() { this.observers = [] } next(t) { for (const e of this.observers) e.next(t) } error(t) { for (const e of this.observers) e.error && e.error(t) } complete() { for (const t of this.observers) t.complete && t.complete() } subscribe(t) { return this.observers.push(t), new v(this, t) } } class L { constructor(t, e, s) { this.C = 1e5, this.S = [], this.k = 0, this.P = !1, this.T = 1, this.I = 0, this._ = 0, this.H = !1, this.D = t, this.R = e, this.C = s } async A(t) { const e = this.D.writeMessage(t); let s = Promise.resolve(); if (this.U(t)) { this.k++; let t = () => { }, i = () => { }; y(e) ? this._ += e.byteLength : this._ += e.length, this._ >= this.C && (s = new Promise(((e, s) => { t = e, i = s }))), this.S.push(new N(e, this.k, t, i)) } try { this.H || await this.R.send(e) } catch { this.L() } await s } N(t) { let e = -1; for (let s = 0; s < this.S.length; s++) { const i = this.S[s]; if (i.q <= t.sequenceId) e = s, y(i.M) ? this._ -= i.M.byteLength : this._ -= i.M.length, i.j(); else { if (!(this._ < this.C)) break; i.j() } } -1 !== e && (this.S = this.S.slice(e + 1)) } W(t) { if (this.P) return t.type === x.Sequence && (this.P = !1, !0); if (!this.U(t)) return !0; const e = this.T; return this.T++, e <= this.I ? (e === this.I && this.O(), !1) : (this.I = e, this.O(), !0) } F(t) { t.sequenceId > this.T ? this.R.stop(new Error("Sequence ID greater than amount of messages we've received.")) : this.T = t.sequenceId } L() { this.H = !0, this.P = !0 } async B() { const t = 0 !== this.S.length ? this.S[0].q : this.k + 1; await this.R.send(this.D.writeMessage({ type: x.Sequence, sequenceId: t })); const e = this.S; for (const t of e) await this.R.send(t.M); this.H = !1 } X(t) { null != t || (t = new Error("Unable to reconnect to server.")); for (const e of this.S) e.J(t) } U(t) { switch (t.type) { case x.Invocation: case x.StreamItem: case x.Completion: case x.StreamInvocation: case x.CancelInvocation: return !0; case x.Close: case x.Sequence: case x.Ping: case x.Ack: return !1 } } O() { void 0 === this.V && (this.V = setTimeout((async () => { try { this.H || await this.R.send(this.D.writeMessage({ type: x.Ack, sequenceId: this.I })) } catch { } clearTimeout(this.V), this.V = void 0 }), 1e3)) } } class N { constructor(t, e, s, i) { this.M = t, this.q = e, this.j = s, this.J = i } } !function (t) { t.Disconnected = "Disconnected", t.Connecting = "Connecting", t.Connected = "Connected", t.Disconnecting = "Disconnecting", t.Reconnecting = "Reconnecting" }(A || (A = {})); class q { static create(t, e, s, i, n, r, o) { return new q(t, e, s, i, n, r, o) } constructor(t, s, i, n, r, o, h) { this.K = 0, this.G = () => { this.u.log(e.Warning, "The page is being frozen, this will likely lead to the connection being closed and messages being lost. For more information see the docs at https://learn.microsoft.com/aspnet/core/signalr/javascript-client#bsleep") }, w.isRequired(t, "connection"), w.isRequired(s, "logger"), w.isRequired(i, "protocol"), this.serverTimeoutInMilliseconds = null != r ? r : 3e4, this.keepAliveIntervalInMilliseconds = null != o ? o : 15e3, this.Y = null != h ? h : 1e5, this.u = s, this.D = i, this.connection = t, this.Z = n, this.tt = new R, this.connection.onreceive = t => this.et(t), this.connection.onclose = t => this.st(t), this.it = {}, this.nt = {}, this.rt = [], this.ot = [], this.ht = [], this.ct = 0, this.lt = !1, this.ut = A.Disconnected, this.dt = !1, this.ft = this.D.writeMessage({ type: x.Ping }) } get state() { return this.ut } get connectionId() { return this.connection && this.connection.connectionId || null } get baseUrl() { return this.connection.baseUrl || "" } set baseUrl(t) { if (this.ut !== A.Disconnected && this.ut !== A.Reconnecting) throw new Error("The HubConnection must be in the Disconnected or Reconnecting state to change the url."); if (!t) throw new Error("The HubConnection url must be a valid url."); this.connection.baseUrl = t } start() { return this.wt = this.gt(), this.wt } async gt() { if (this.ut !== A.Disconnected) return Promise.reject(new Error("Cannot start a HubConnection that is not in the 'Disconnected' state.")); this.ut = A.Connecting, this.u.log(e.Debug, "Starting HubConnection."); try { await this.yt(), g.isBrowser && window.document.addEventListener("freeze", this.G), this.ut = A.Connected, this.dt = !0, this.u.log(e.Debug, "HubConnection connected successfully.") } catch (t) { return this.ut = A.Disconnected, this.u.log(e.Debug, `HubConnection failed to start successfully because of error '${t}'.`), Promise.reject(t) } } async yt() { this.bt = void 0, this.lt = !1; const t = new Promise(((t, e) => { this.vt = t, this.Et = e })); await this.connection.start(this.D.transferFormat); try { let s = this.D.version; this.connection.features.reconnect || (s = 1); const i = { protocol: this.D.name, version: s }; if (this.u.log(e.Debug, "Sending handshake request."), await this.$t(this.tt.writeHandshakeRequest(i)), this.u.log(e.Information, `Using HubProtocol '${this.D.name}'.`), this.Ct(), this.St(), this.kt(), await t, this.bt) throw this.bt; !!this.connection.features.reconnect && (this.Pt = new L(this.D, this.connection, this.Y), this.connection.features.disconnected = this.Pt.L.bind(this.Pt), this.connection.features.resend = () => { if (this.Pt) return this.Pt.B() }), this.connection.features.inherentKeepAlive || await this.$t(this.ft) } catch (t) { throw this.u.log(e.Debug, `Hub handshake failed with error '${t}' during start(). Stopping HubConnection.`), this.Ct(), this.Tt(), await this.connection.stop(t), t } } async stop() { const t = this.wt; this.connection.features.reconnect = !1, this.It = this._t(), await this.It; try { await t } catch (t) { } } _t(t) { if (this.ut === A.Disconnected) return this.u.log(e.Debug, `Call to HubConnection.stop(${t}) ignored because it is already in the disconnected state.`), Promise.resolve(); if (this.ut === A.Disconnecting) return this.u.log(e.Debug, `Call to HttpConnection.stop(${t}) ignored because the connection is already in the disconnecting state.`), this.It; const s = this.ut; return this.ut = A.Disconnecting, this.u.log(e.Debug, "Stopping HubConnection."), this.Ht ? (this.u.log(e.Debug, "Connection stopped during reconnect delay. Done reconnecting."), clearTimeout(this.Ht), this.Ht = void 0, this.Dt(), Promise.resolve()) : (s === A.Connected && this.Rt(), this.Ct(), this.Tt(), this.bt = t || new r("The connection was stopped before the hub handshake could complete."), this.connection.stop(t)) } async Rt() { try { await this.xt(this.At()) } catch { } } stream(t, ...e) { const [s, i] = this.Ut(e), n = this.Lt(t, e, i); let r; const o = new U; return o.cancelCallback = () => { const t = this.Nt(n.invocationId); return delete this.it[n.invocationId], r.then((() => this.xt(t))) }, this.it[n.invocationId] = (t, e) => { e ? o.error(e) : t && (t.type === x.Completion ? t.error ? o.error(new Error(t.error)) : o.complete() : o.next(t.item)) }, r = this.xt(n).catch((t => { o.error(t), delete this.it[n.invocationId] })), this.qt(s, r), o } $t(t) { return this.kt(), this.connection.send(t) } xt(t) { return this.Pt ? this.Pt.A(t) : this.$t(this.D.writeMessage(t)) } send(t, ...e) { const [s, i] = this.Ut(e), n = this.xt(this.Mt(t, e, !0, i)); return this.qt(s, n), n } invoke(t, ...e) { const [s, i] = this.Ut(e), n = this.Mt(t, e, !1, i); return new Promise(((t, e) => { this.it[n.invocationId] = (s, i) => { i ? e(i) : s && (s.type === x.Completion ? s.error ? e(new Error(s.error)) : t(s.result) : e(new Error(`Unexpected message type: ${s.type}`))) }; const i = this.xt(n).catch((t => { e(t), delete this.it[n.invocationId] })); this.qt(s, i) })) } on(t, e) { t && e && (t = t.toLowerCase(), this.nt[t] || (this.nt[t] = []), -1 === this.nt[t].indexOf(e) && this.nt[t].push(e)) } off(t, e) { if (!t) return; t = t.toLowerCase(); const s = this.nt[t]; if (s) if (e) { const i = s.indexOf(e); -1 !== i && (s.splice(i, 1), 0 === s.length && delete this.nt[t]) } else delete this.nt[t] } onclose(t) { t && this.rt.push(t) } onreconnecting(t) { t && this.ot.push(t) } onreconnected(t) { t && this.ht.push(t) } et(t) { if (this.Ct(), this.lt || (t = this.jt(t), this.lt = !0), t) { const s = this.D.parseMessages(t, this.u); for (const t of s) if (!this.Pt || this.Pt.W(t)) switch (t.type) { case x.Invocation: this.Wt(t).catch((t => { this.u.log(e.Error, `Invoke client method threw error: ${P(t)}`) })); break; case x.StreamItem: case x.Completion: { const s = this.it[t.invocationId]; if (s) { t.type === x.Completion && delete this.it[t.invocationId]; try { s(t) } catch (t) { this.u.log(e.Error, `Stream callback threw error: ${P(t)}`) } } break } case x.Ping: break; case x.Close: { this.u.log(e.Information, "Close message received from server."); const s = t.error ? new Error("Server returned an error on close: " + t.error) : void 0; !0 === t.allowReconnect ? this.connection.stop(s) : this.It = this._t(s); break } case x.Ack: this.Pt && this.Pt.N(t); break; case x.Sequence: this.Pt && this.Pt.F(t); break; default: this.u.log(e.Warning, `Invalid message type: ${t.type}.`) } } this.St() } jt(t) { let s, i; try { [i, s] = this.tt.parseHandshakeResponse(t) } catch (t) { const s = "Error parsing handshake response: " + t; this.u.log(e.Error, s); const i = new Error(s); throw this.Et(i), i } if (s.error) { const t = "Server returned handshake error: " + s.error; this.u.log(e.Error, t); const i = new Error(t); throw this.Et(i), i } return this.u.log(e.Debug, "Server handshake complete."), this.vt(), i } kt() { this.connection.features.inherentKeepAlive || (this.K = (new Date).getTime() + this.keepAliveIntervalInMilliseconds, this.Tt()) } St() { if (!(this.connection.features && this.connection.features.inherentKeepAlive || (this.Ot = setTimeout((() => this.serverTimeout()), this.serverTimeoutInMilliseconds), void 0 !== this.Ft))) { let t = this.K - (new Date).getTime(); t < 0 && (t = 0), this.Ft = setTimeout((async () => { if (this.ut === A.Connected) try { await this.$t(this.ft) } catch { this.Tt() } }), t) } } serverTimeout() { this.connection.stop(new Error("Server timeout elapsed without receiving a message from the server.")) } async Wt(t) { const s = t.target.toLowerCase(), i = this.nt[s]; if (!i) return this.u.log(e.Warning, `No client method with the name '${s}' found.`), void (t.invocationId && (this.u.log(e.Warning, `No result given for '${s}' method and invocation ID '${t.invocationId}'.`), await this.xt(this.Bt(t.invocationId, "Client didn't provide a result.", null)))); const n = i.slice(), r = !!t.invocationId; let o, h, c; for (const i of n) try { const n = o; o = await i.apply(this, t.arguments), r && o && n && (this.u.log(e.Error, `Multiple results provided for '${s}'. Sending error to server.`), c = this.Bt(t.invocationId, "Client provided multiple results.", null)), h = void 0 } catch (t) { h = t, this.u.log(e.Error, `A callback for the method '${s}' threw error '${t}'.`) } c ? await this.xt(c) : r ? (h ? c = this.Bt(t.invocationId, `${h}`, null) : void 0 !== o ? c = this.Bt(t.invocationId, null, o) : (this.u.log(e.Warning, `No result given for '${s}' method and invocation ID '${t.invocationId}'.`), c = this.Bt(t.invocationId, "Client didn't provide a result.", null)), await this.xt(c)) : o && this.u.log(e.Error, `Result given for '${s}' method but server is not expecting a result.`) } st(t) { this.u.log(e.Debug, `HubConnection.connectionClosed(${t}) called while in state ${this.ut}.`), this.bt = this.bt || t || new r("The underlying connection was closed before the hub handshake could complete."), this.vt && this.vt(), this.Xt(t || new Error("Invocation canceled due to the underlying connection being closed.")), this.Ct(), this.Tt(), this.ut === A.Disconnecting ? this.Dt(t) : this.ut === A.Connected && this.Z ? this.Jt(t) : this.ut === A.Connected && this.Dt(t) } Dt(t) { if (this.dt) { this.ut = A.Disconnected, this.dt = !1, this.Pt && (this.Pt.X(null != t ? t : new Error("Connection closed.")), this.Pt = void 0), g.isBrowser && window.document.removeEventListener("freeze", this.G); try { this.rt.forEach((e => e.apply(this, [t]))) } catch (s) { this.u.log(e.Error, `An onclose callback called with error '${t}' threw error '${s}'.`) } } } async Jt(t) { const s = Date.now(); let i = 0, n = void 0 !== t ? t : new Error("Attempting to reconnect due to a unknown error."), r = this.zt(i++, 0, n); if (null === r) return this.u.log(e.Debug, "Connection not reconnecting because the IRetryPolicy returned null on the first reconnect attempt."), void this.Dt(t); if (this.ut = A.Reconnecting, t ? this.u.log(e.Information, `Connection reconnecting because of error '${t}'.`) : this.u.log(e.Information, "Connection reconnecting."), 0 !== this.ot.length) { try { this.ot.forEach((e => e.apply(this, [t]))) } catch (s) { this.u.log(e.Error, `An onreconnecting callback called with error '${t}' threw error '${s}'.`) } if (this.ut !== A.Reconnecting) return void this.u.log(e.Debug, "Connection left the reconnecting state in onreconnecting callback. Done reconnecting.") } for (; null !== r;) { if (this.u.log(e.Information, `Reconnect attempt number ${i} will start in ${r} ms.`), await new Promise((t => { this.Ht = setTimeout(t, r) })), this.Ht = void 0, this.ut !== A.Reconnecting) return void this.u.log(e.Debug, "Connection left the reconnecting state during reconnect delay. Done reconnecting."); try { if (await this.yt(), this.ut = A.Connected, this.u.log(e.Information, "HubConnection reconnected successfully."), 0 !== this.ht.length) try { this.ht.forEach((t => t.apply(this, [this.connection.connectionId]))) } catch (t) { this.u.log(e.Error, `An onreconnected callback called with connectionId '${this.connection.connectionId}; threw error '${t}'.`) } return } catch (t) { if (this.u.log(e.Information, `Reconnect attempt failed because of error '${t}'.`), this.ut !== A.Reconnecting) return this.u.log(e.Debug, `Connection moved to the '${this.ut}' from the reconnecting state during reconnect attempt. Done reconnecting.`), void (this.ut === A.Disconnecting && this.Dt()); n = t instanceof Error ? t : new Error(t.toString()), r = this.zt(i++, Date.now() - s, n) } } this.u.log(e.Information, `Reconnect retries have been exhausted after ${Date.now() - s} ms and ${i} failed attempts. Connection disconnecting.`), this.Dt() } zt(t, s, i) { try { return this.Z.nextRetryDelayInMilliseconds({ elapsedMilliseconds: s, previousRetryCount: t, retryReason: i }) } catch (i) { return this.u.log(e.Error, `IRetryPolicy.nextRetryDelayInMilliseconds(${t}, ${s}) threw error '${i}'.`), null } } Xt(t) { const s = this.it; this.it = {}, Object.keys(s).forEach((i => { const n = s[i]; try { n(null, t) } catch (s) { this.u.log(e.Error, `Stream 'error' callback called with '${t}' threw error: ${P(s)}`) } })) } Tt() { this.Ft && (clearTimeout(this.Ft), this.Ft = void 0) } Ct() { this.Ot && clearTimeout(this.Ot) } Mt(t, e, s, i) { if (s) return 0 !== i.length ? { arguments: e, streamIds: i, target: t, type: x.Invocation } : { arguments: e, target: t, type: x.Invocation }; { const s = this.ct; return this.ct++, 0 !== i.length ? { arguments: e, invocationId: s.toString(), streamIds: i, target: t, type: x.Invocation } : { arguments: e, invocationId: s.toString(), target: t, type: x.Invocation } } } qt(t, e) { if (0 !== t.length) { e || (e = Promise.resolve()); for (const s in t) t[s].subscribe({ complete: () => { e = e.then((() => this.xt(this.Bt(s)))) }, error: t => { let i; i = t instanceof Error ? t.message : t && t.toString ? t.toString() : "Unknown error", e = e.then((() => this.xt(this.Bt(s, i)))) }, next: t => { e = e.then((() => this.xt(this.Vt(s, t)))) } }) } } Ut(t) { const e = [], s = []; for (let i = 0; i < t.length; i++) { const n = t[i]; if (this.Kt(n)) { const r = this.ct; this.ct++, e[r] = n, s.push(r.toString()), t.splice(i, 1) } } return [e, s] } Kt(t) { return t && t.subscribe && "function" == typeof t.subscribe } Lt(t, e, s) { const i = this.ct; return this.ct++, 0 !== s.length ? { arguments: e, invocationId: i.toString(), streamIds: s, target: t, type: x.StreamInvocation } : { arguments: e, invocationId: i.toString(), target: t, type: x.StreamInvocation } } Nt(t) { return { invocationId: t, type: x.CancelInvocation } } Vt(t, e) { return { invocationId: t, item: e, type: x.StreamItem } } Bt(t, e, s) { return e ? { error: e, invocationId: t, type: x.Completion } : { invocationId: t, result: s, type: x.Completion } } At() { return { type: x.Close } } } const M = [0, 2e3, 1e4, 3e4, null]; class j { constructor(t) { this.Gt = void 0 !== t ? [...t, null] : M } nextRetryDelayInMilliseconds(t) { return this.Gt[t.previousRetryCount] } } class W { } W.Authorization = "Authorization", W.Cookie = "Cookie"; class O extends d { constructor(t, e) { super(), this.Qt = t, this.Yt = e } async send(t) { let e = !0; this.Yt && (!this.Zt || t.url && t.url.indexOf("/negotiate?") > 0) && (e = !1, this.Zt = await this.Yt()), this.te(t); const s = await this.Qt.send(t); return e && 401 === s.statusCode && this.Yt ? (this.Zt = await this.Yt(), this.te(t), await this.Qt.send(t)) : s } te(t) { t.headers || (t.headers = {}), this.Zt ? t.headers[W.Authorization] = `Bearer ${this.Zt}` : this.Yt && t.headers[W.Authorization] && delete t.headers[W.Authorization] } getCookieString(t) { return this.Qt.getCookieString(t) } } var F, B; !function (t) { t[t.None = 0] = "None", t[t.WebSockets = 1] = "WebSockets", t[t.ServerSentEvents = 2] = "ServerSentEvents", t[t.LongPolling = 4] = "LongPolling" }(F || (F = {})), function (t) { t[t.Text = 1] = "Text", t[t.Binary = 2] = "Binary" }(B || (B = {})); class X { constructor() { this.ee = !1, this.onabort = null } abort() { this.ee || (this.ee = !0, this.onabort && this.onabort()) } get signal() { return this } get aborted() { return this.ee } } class J { get pollAborted() { return this.se.aborted } constructor(t, e, s) { this.$ = t, this.u = e, this.se = new X, this.ie = s, this.ne = !1, this.onreceive = null, this.onclose = null } async connect(t, s) { if (w.isRequired(t, "url"), w.isRequired(s, "transferFormat"), w.isIn(s, B, "transferFormat"), this.re = t, this.u.log(e.Trace, "(LongPolling transport) Connecting."), s === B.Binary && "undefined" != typeof XMLHttpRequest && "string" != typeof (new XMLHttpRequest).responseType) throw new Error("Binary protocols over XmlHttpRequest not implementing advanced features are not supported."); const [n, r] = $(), o = { [n]: r, ...this.ie.headers }, h = { abortSignal: this.se.signal, headers: o, timeout: 1e5, withCredentials: this.ie.withCredentials }; s === B.Binary && (h.responseType = "arraybuffer"); const c = `${t}&_=${Date.now()}`; this.u.log(e.Trace, `(LongPolling transport) polling: ${c}.`); const a = await this.$.get(c, h); 200 !== a.statusCode ? (this.u.log(e.Error, `(LongPolling transport) Unexpected response code: ${a.statusCode}.`), this.oe = new i(a.statusText || "", a.statusCode), this.ne = !1) : this.ne = !0, this.he = this.ce(this.re, h) } async ce(t, s) { try { for (; this.ne;)try { const n = `${t}&_=${Date.now()}`; this.u.log(e.Trace, `(LongPolling transport) polling: ${n}.`); const r = await this.$.get(n, s); 204 === r.statusCode ? (this.u.log(e.Information, "(LongPolling transport) Poll terminated by server."), this.ne = !1) : 200 !== r.statusCode ? (this.u.log(e.Error, `(LongPolling transport) Unexpected response code: ${r.statusCode}.`), this.oe = new i(r.statusText || "", r.statusCode), this.ne = !1) : r.content ? (this.u.log(e.Trace, `(LongPolling transport) data received. ${m(r.content, this.ie.logMessageContent)}.`), this.onreceive && this.onreceive(r.content)) : this.u.log(e.Trace, "(LongPolling transport) Poll timed out, reissuing.") } catch (t) { this.ne ? t instanceof n ? this.u.log(e.Trace, "(LongPolling transport) Poll timed out, reissuing.") : (this.oe = t, this.ne = !1) : this.u.log(e.Trace, `(LongPolling transport) Poll errored after shutdown: ${t.message}`) } } finally { this.u.log(e.Trace, "(LongPolling transport) Polling complete."), this.pollAborted || this.ae() } } async send(t) { return this.ne ? b(this.u, "LongPolling", this.$, this.re, t, this.ie) : Promise.reject(new Error("Cannot send until the transport is connected")) } async stop() { this.u.log(e.Trace, "(LongPolling transport) Stopping polling."), this.ne = !1, this.se.abort(); try { await this.he, this.u.log(e.Trace, `(LongPolling transport) sending DELETE request to ${this.re}.`); const t = {}, [s, n] = $(); t[s] = n; const r = { headers: { ...t, ...this.ie.headers }, timeout: this.ie.timeout, withCredentials: this.ie.withCredentials }; let o; try { await this.$.delete(this.re, r) } catch (t) { o = t } o ? o instanceof i && (404 === o.statusCode ? this.u.log(e.Trace, "(LongPolling transport) A 404 response was returned from sending a DELETE request.") : this.u.log(e.Trace, `(LongPolling transport) Error sending a DELETE request: ${o}`)) : this.u.log(e.Trace, "(LongPolling transport) DELETE request accepted.") } finally { this.u.log(e.Trace, "(LongPolling transport) Stop finished."), this.ae() } } ae() { if (this.onclose) { let t = "(LongPolling transport) Firing onclose event."; this.oe && (t += " Error: " + this.oe), this.u.log(e.Trace, t), this.onclose(this.oe) } } } class z { constructor(t, e, s, i) { this.$ = t, this.Zt = e, this.u = s, this.ie = i, this.onreceive = null, this.onclose = null } async connect(t, s) { return w.isRequired(t, "url"), w.isRequired(s, "transferFormat"), w.isIn(s, B, "transferFormat"), this.u.log(e.Trace, "(SSE transport) Connecting."), this.re = t, this.Zt && (t += (t.indexOf("?") < 0 ? "?" : "&") + `access_token=${encodeURIComponent(this.Zt)}`), new Promise(((i, n) => { let r, o = !1; if (s === B.Text) { if (g.isBrowser || g.isWebWorker) r = new this.ie.EventSource(t, { withCredentials: this.ie.withCredentials }); else { const e = this.$.getCookieString(t), s = {}; s.Cookie = e; const [i, n] = $(); s[i] = n, r = new this.ie.EventSource(t, { withCredentials: this.ie.withCredentials, headers: { ...s, ...this.ie.headers } }) } try { r.onmessage = t => { if (this.onreceive) try { this.u.log(e.Trace, `(SSE transport) data received. ${m(t.data, this.ie.logMessageContent)}.`), this.onreceive(t.data) } catch (t) { return void this.le(t) } }, r.onerror = t => { o ? this.le() : n(new Error("EventSource failed to connect. The connection could not be found on the server, either the connection ID is not present on the server, or a proxy is refusing/buffering the connection. If you have multiple servers check that sticky sessions are enabled.")) }, r.onopen = () => { this.u.log(e.Information, `SSE connected to ${this.re}`), this.ue = r, o = !0, i() } } catch (t) { return void n(t) } } else n(new Error("The Server-Sent Events transport only supports the 'Text' transfer format")) })) } async send(t) { return this.ue ? b(this.u, "SSE", this.$, this.re, t, this.ie) : Promise.reject(new Error("Cannot send until the transport is connected")) } stop() { return this.le(), Promise.resolve() } le(t) { this.ue && (this.ue.close(), this.ue = void 0, this.onclose && this.onclose(t)) } } class V { constructor(t, e, s, i, n, r) { this.u = s, this.Yt = e, this.de = i, this.fe = n, this.$ = t, this.onreceive = null, this.onclose = null, this.pe = r } async connect(t, s) { let i; return w.isRequired(t, "url"), w.isRequired(s, "transferFormat"), w.isIn(s, B, "transferFormat"), this.u.log(e.Trace, "(WebSockets transport) Connecting."), this.Yt && (i = await this.Yt()), new Promise(((n, r) => { let o; t = t.replace(/^http/, "ws"); const h = this.$.getCookieString(t); let c = !1; if (g.isNode || g.isReactNative) { const e = {}, [s, n] = $(); e[s] = n, i && (e[W.Authorization] = `Bearer ${i}`), h && (e[W.Cookie] = h), o = new this.fe(t, void 0, { headers: { ...e, ...this.pe } }) } else i && (t += (t.indexOf("?") < 0 ? "?" : "&") + `access_token=${encodeURIComponent(i)}`); o || (o = new this.fe(t)), s === B.Binary && (o.binaryType = "arraybuffer"), o.onopen = s => { this.u.log(e.Information, `WebSocket connected to ${t}.`), this.we = o, c = !0, n() }, o.onerror = t => { let s = null; s = "undefined" != typeof ErrorEvent && t instanceof ErrorEvent ? t.error : "There was an error with the transport", this.u.log(e.Information, `(WebSockets transport) ${s}.`) }, o.onmessage = t => { if (this.u.log(e.Trace, `(WebSockets transport) data received. ${m(t.data, this.de)}.`), this.onreceive) try { this.onreceive(t.data) } catch (t) { return void this.le(t) } }, o.onclose = t => { if (c) this.le(t); else { let e = null; e = "undefined" != typeof ErrorEvent && t instanceof ErrorEvent ? t.error : "WebSocket failed to connect. The connection could not be found on the server, either the endpoint may not be a SignalR endpoint, the connection ID is not present on the server, or there is a proxy blocking WebSockets. If you have multiple servers check that sticky sessions are enabled.", r(new Error(e)) } } })) } send(t) { return this.we && this.we.readyState === this.fe.OPEN ? (this.u.log(e.Trace, `(WebSockets transport) sending data. ${m(t, this.de)}.`), this.we.send(t), Promise.resolve()) : Promise.reject("WebSocket is not in the OPEN state") } stop() { return this.we && this.le(void 0), Promise.resolve() } le(t) { this.we && (this.we.onclose = () => { }, this.we.onmessage = () => { }, this.we.onerror = () => { }, this.we.close(), this.we = void 0), this.u.log(e.Trace, "(WebSockets transport) socket closed."), this.onclose && (!this.ge(t) || !1 !== t.wasClean && 1e3 === t.code ? t instanceof Error ? this.onclose(t) : this.onclose() : this.onclose(new Error(`WebSocket closed with status code: ${t.code} (${t.reason || "no reason given"}).`))) } ge(t) { return t && "boolean" == typeof t.wasClean && "number" == typeof t.code } } class K { constructor(t, s = {}) { var i; if (this.me = () => { }, this.features = {}, this.ye = 1, w.isRequired(t, "url"), this.u = void 0 === (i = s.logger) ? new E(e.Information) : null === i ? f.instance : void 0 !== i.log ? i : new E(i), this.baseUrl = this.be(t), (s = s || {}).logMessageContent = void 0 !== s.logMessageContent && s.logMessageContent, "boolean" != typeof s.withCredentials && void 0 !== s.withCredentials) throw new Error("withCredentials option was not a 'boolean' or 'undefined' value"); s.withCredentials = void 0 === s.withCredentials || s.withCredentials, s.timeout = void 0 === s.timeout ? 1e5 : s.timeout; let n = null, r = null; if (g.isNode) { const t = require; n = t("ws"), r = t("eventsource") } g.isNode || "undefined" == typeof WebSocket || s.WebSocket ? g.isNode && !s.WebSocket && n && (s.WebSocket = n) : s.WebSocket = WebSocket, g.isNode || "undefined" == typeof EventSource || s.EventSource ? g.isNode && !s.EventSource && void 0 !== r && (s.EventSource = r) : s.EventSource = EventSource, this.$ = new O(s.httpClient || new H(this.u), s.accessTokenFactory), this.ut = "Disconnected", this.dt = !1, this.ie = s, this.onreceive = null, this.onclose = null } async start(t) { if (t = t || B.Binary, w.isIn(t, B, "transferFormat"), this.u.log(e.Debug, `Starting connection with transfer format '${B[t]}'.`), "Disconnected" !== this.ut) return Promise.reject(new Error("Cannot start an HttpConnection that is not in the 'Disconnected' state.")); if (this.ut = "Connecting", this.ve = this.yt(t), await this.ve, "Disconnecting" === this.ut) { const t = "Failed to start the HttpConnection before stop() was called."; return this.u.log(e.Error, t), await this.It, Promise.reject(new r(t)) } if ("Connected" !== this.ut) { const t = "HttpConnection.startInternal completed gracefully but didn't enter the connection into the connected state!"; return this.u.log(e.Error, t), Promise.reject(new r(t)) } this.dt = !0 } send(t) { return "Connected" !== this.ut ? Promise.reject(new Error("Cannot send data if the connection is not in the 'Connected' State.")) : (this.Ee || (this.Ee = new G(this.transport)), this.Ee.send(t)) } async stop(t) { return "Disconnected" === this.ut ? (this.u.log(e.Debug, `Call to HttpConnection.stop(${t}) ignored because the connection is already in the disconnected state.`), Promise.resolve()) : "Disconnecting" === this.ut ? (this.u.log(e.Debug, `Call to HttpConnection.stop(${t}) ignored because the connection is already in the disconnecting state.`), this.It) : (this.ut = "Disconnecting", this.It = new Promise((t => { this.me = t })), await this._t(t), void await this.It) } async _t(t) { this.$e = t; try { await this.ve } catch (t) { } if (this.transport) { try { await this.transport.stop() } catch (t) { this.u.log(e.Error, `HttpConnection.transport.stop() threw error '${t}'.`), this.Ce() } this.transport = void 0 } else this.u.log(e.Debug, "HttpConnection.transport is undefined in HttpConnection.stop() because start() failed.") } async yt(t) { let s = this.baseUrl; this.Yt = this.ie.accessTokenFactory, this.$.Yt = this.Yt; try { if (this.ie.skipNegotiation) { if (this.ie.transport !== F.WebSockets) throw new Error("Negotiation can only be skipped when using the WebSocket transport directly."); this.transport = this.Se(F.WebSockets), await this.ke(s, t) } else { let e = null, i = 0; do { if (e = await this.Pe(s), "Disconnecting" === this.ut || "Disconnected" === this.ut) throw new r("The connection was stopped during negotiation."); if (e.error) throw new Error(e.error); if (e.ProtocolVersion) throw new Error("Detected a connection attempt to an ASP.NET SignalR Server. This client only supports connecting to an ASP.NET Core SignalR Server. See https://aka.ms/signalr-core-differences for details."); if (e.url && (s = e.url), e.accessToken) { const t = e.accessToken; this.Yt = () => t, this.$.Zt = t, this.$.Yt = void 0 } i++ } while (e.url && i < 100); if (100 === i && e.url) throw new Error("Negotiate redirection limit exceeded."); await this.Te(s, this.ie.transport, e, t) } this.transport instanceof J && (this.features.inherentKeepAlive = !0), "Connecting" === this.ut && (this.u.log(e.Debug, "The HttpConnection connected successfully."), this.ut = "Connected") } catch (t) { return this.u.log(e.Error, "Failed to start the connection: " + t), this.ut = "Disconnected", this.transport = void 0, this.me(), Promise.reject(t) } } async Pe(t) { const s = {}, [n, r] = $(); s[n] = r; const o = this.Ie(t); this.u.log(e.Debug, `Sending negotiation request: ${o}.`); try { const t = await this.$.post(o, { content: "", headers: { ...s, ...this.ie.headers }, timeout: this.ie.timeout, withCredentials: this.ie.withCredentials }); if (200 !== t.statusCode) return Promise.reject(new Error(`Unexpected status code returned from negotiate '${t.statusCode}'`)); const e = JSON.parse(t.content); return (!e.negotiateVersion || e.negotiateVersion < 1) && (e.connectionToken = e.connectionId), e.useStatefulReconnect && !0 !== this.ie._e ? Promise.reject(new a("Client didn't negotiate Stateful Reconnect but the server did.")) : e } catch (t) { let s = "Failed to complete negotiation with the server: " + t; return t instanceof i && 404 === t.statusCode && (s += " Either this is not a SignalR endpoint or there is a proxy blocking the connection."), this.u.log(e.Error, s), Promise.reject(new a(s)) } } He(t, e) { return e ? t + (-1 === t.indexOf("?") ? "?" : "&") + `id=${e}` : t } async Te(t, s, i, n) { let o = this.He(t, i.connectionToken); if (this.De(s)) return this.u.log(e.Debug, "Connection was provided an instance of ITransport, using that directly."), this.transport = s, await this.ke(o, n), void (this.connectionId = i.connectionId); const h = [], a = i.availableTransports || []; let u = i; for (const i of a) { const a = this.Re(i, s, n, !0 === (null == u ? void 0 : u.useStatefulReconnect)); if (a instanceof Error) h.push(`${i.transport} failed:`), h.push(a); else if (this.De(a)) { if (this.transport = a, !u) { try { u = await this.Pe(t) } catch (t) { return Promise.reject(t) } o = this.He(t, u.connectionToken) } try { return await this.ke(o, n), void (this.connectionId = u.connectionId) } catch (t) { if (this.u.log(e.Error, `Failed to start the transport '${i.transport}': ${t}`), u = void 0, h.push(new c(`${i.transport} failed: ${t}`, F[i.transport])), "Connecting" !== this.ut) { const t = "Failed to select transport before stop() was called."; return this.u.log(e.Debug, t), Promise.reject(new r(t)) } } } } return h.length > 0 ? Promise.reject(new l(`Unable to connect to the server with any of the available transports. ${h.join(" ")}`, h)) : Promise.reject(new Error("None of the transports supported by the client are supported by the server.")) } Se(t) { switch (t) { case F.WebSockets: if (!this.ie.WebSocket) throw new Error("'WebSocket' is not supported in your environment."); return new V(this.$, this.Yt, this.u, this.ie.logMessageContent, this.ie.WebSocket, this.ie.headers || {}); case F.ServerSentEvents: if (!this.ie.EventSource) throw new Error("'EventSource' is not supported in your environment."); return new z(this.$, this.$.Zt, this.u, this.ie); case F.LongPolling: return new J(this.$, this.u, this.ie); default: throw new Error(`Unknown transport: ${t}.`) } } ke(t, e) { return this.transport.onreceive = this.onreceive, this.features.reconnect ? this.transport.onclose = async s => { let i = !1; if (this.features.reconnect) { try { this.features.disconnected(), await this.transport.connect(t, e), await this.features.resend() } catch { i = !0 } i && this.Ce(s) } else this.Ce(s) } : this.transport.onclose = t => this.Ce(t), this.transport.connect(t, e) } Re(t, s, i, n) { const r = F[t.transport]; if (null == r) return this.u.log(e.Debug, `Skipping transport '${t.transport}' because it is not supported by this client.`), new Error(`Skipping transport '${t.transport}' because it is not supported by this client.`); if (!function (t, e) { return !t || 0 != (e & t) }(s, r)) return this.u.log(e.Debug, `Skipping transport '${F[r]}' because it was disabled by the client.`), new h(`'${F[r]}' is disabled by the client.`, r); if (!(t.transferFormats.map((t => B[t])).indexOf(i) >= 0)) return this.u.log(e.Debug, `Skipping transport '${F[r]}' because it does not support the requested transfer format '${B[i]}'.`), new Error(`'${F[r]}' does not support ${B[i]}.`); if (r === F.WebSockets && !this.ie.WebSocket || r === F.ServerSentEvents && !this.ie.EventSource) return this.u.log(e.Debug, `Skipping transport '${F[r]}' because it is not supported in your environment.'`), new o(`'${F[r]}' is not supported in your environment.`, r); this.u.log(e.Debug, `Selecting transport '${F[r]}'.`); try { return this.features.reconnect = r === F.WebSockets ? n : void 0, this.Se(r) } catch (t) { return t } } De(t) { return t && "object" == typeof t && "connect" in t } Ce(t) { if (this.u.log(e.Debug, `HttpConnection.stopConnection(${t}) called while in state ${this.ut}.`), this.transport = void 0, t = this.$e || t, this.$e = void 0, "Disconnected" !== this.ut) { if ("Connecting" === this.ut) throw this.u.log(e.Warning, `Call to HttpConnection.stopConnection(${t}) was ignored because the connection is still in the connecting state.`), new Error(`HttpConnection.stopConnection(${t}) was called while the connection is still in the connecting state.`); if ("Disconnecting" === this.ut && this.me(), t ? this.u.log(e.Error, `Connection disconnected with error '${t}'.`) : this.u.log(e.Information, "Connection disconnected."), this.Ee && (this.Ee.stop().catch((t => { this.u.log(e.Error, `TransportSendQueue.stop() threw error '${t}'.`) })), this.Ee = void 0), this.connectionId = void 0, this.ut = "Disconnected", this.dt) { this.dt = !1; try { this.onclose && this.onclose(t) } catch (s) { this.u.log(e.Error, `HttpConnection.onclose(${t}) threw error '${s}'.`) } } } else this.u.log(e.Debug, `Call to HttpConnection.stopConnection(${t}) was ignored because the connection is already in the disconnected state.`) } be(t) { if (0 === t.lastIndexOf("https://", 0) || 0 === t.lastIndexOf("http://", 0)) return t; if (!g.isBrowser) throw new Error(`Cannot resolve '${t}'.`); const s = window.document.createElement("a"); return s.href = t, this.u.log(e.Information, `Normalizing '${t}' to '${s.href}'.`), s.href } Ie(t) { const e = new URL(t); e.pathname.endsWith("/") ? e.pathname += "negotiate" : e.pathname += "/negotiate"; const s = new URLSearchParams(e.searchParams); return s.has("negotiateVersion") || s.append("negotiateVersion", this.ye.toString()), s.has("useStatefulReconnect") ? "true" === s.get("useStatefulReconnect") && (this.ie._e = !0) : !0 === this.ie._e && s.append("useStatefulReconnect", "true"), e.search = s.toString(), e.toString() } } class G { constructor(t) { this.xe = t, this.Ae = [], this.Ue = !0, this.Le = new Q, this.Ne = new Q, this.qe = this.Me() } send(t) { return this.je(t), this.Ne || (this.Ne = new Q), this.Ne.promise } stop() { return this.Ue = !1, this.Le.resolve(), this.qe } je(t) { if (this.Ae.length && typeof this.Ae[0] != typeof t) throw new Error(`Expected data to be of type ${typeof this.Ae} but was of type ${typeof t}`); this.Ae.push(t), this.Le.resolve() } async Me() { for (; ;) { if (await this.Le.promise, !this.Ue) { this.Ne && this.Ne.reject("Connection stopped."); break } this.Le = new Q; const t = this.Ne; this.Ne = void 0; const e = "string" == typeof this.Ae[0] ? this.Ae.join("") : G.We(this.Ae); this.Ae.length = 0; try { await this.xe.send(e), t.resolve() } catch (e) { t.reject(e) } } } static We(t) { const e = t.map((t => t.byteLength)).reduce(((t, e) => t + e)), s = new Uint8Array(e); let i = 0; for (const e of t) s.set(new Uint8Array(e), i), i += e.byteLength; return s.buffer } } class Q { constructor() { this.promise = new Promise(((t, e) => [this.j, this.Oe] = [t, e])) } resolve() { this.j() } reject(t) { this.Oe(t) } } class Y { constructor() { this.name = "json", this.version = 2, this.transferFormat = B.Text } parseMessages(t, s) { if ("string" != typeof t) throw new Error("Invalid input for JSON hub protocol. Expected a string."); if (!t) return []; null === s && (s = f.instance); const i = D.parse(t), n = []; for (const t of i) { const i = JSON.parse(t); if ("number" != typeof i.type) throw new Error("Invalid payload."); switch (i.type) { case x.Invocation: this.U(i); break; case x.StreamItem: this.Fe(i); break; case x.Completion: this.Be(i); break; case x.Ping: case x.Close: break; case x.Ack: this.Xe(i); break; case x.Sequence: this.Je(i); break; default: s.log(e.Information, "Unknown message type '" + i.type + "' ignored."); continue }n.push(i) } return n } writeMessage(t) { return D.write(JSON.stringify(t)) } U(t) { this.ze(t.target, "Invalid payload for Invocation message."), void 0 !== t.invocationId && this.ze(t.invocationId, "Invalid payload for Invocation message.") } Fe(t) { if (this.ze(t.invocationId, "Invalid payload for StreamItem message."), void 0 === t.item) throw new Error("Invalid payload for StreamItem message.") } Be(t) { if (t.result && t.error) throw new Error("Invalid payload for Completion message."); !t.result && t.error && this.ze(t.error, "Invalid payload for Completion message."), this.ze(t.invocationId, "Invalid payload for Completion message.") } Xe(t) { if ("number" != typeof t.sequenceId) throw new Error("Invalid SequenceId for Ack message.") } Je(t) { if ("number" != typeof t.sequenceId) throw new Error("Invalid SequenceId for Sequence message.") } ze(t, e) { if ("string" != typeof t || "" === t) throw new Error(e) } } const Z = { trace: e.Trace, debug: e.Debug, info: e.Information, information: e.Information, warn: e.Warning, warning: e.Warning, error: e.Error, critical: e.Critical, none: e.None }; class tt { configureLogging(t) { if (w.isRequired(t, "logging"), void 0 !== t.log) this.logger = t; else if ("string" == typeof t) { const e = function (t) { const e = Z[t.toLowerCase()]; if (void 0 !== e) return e; throw new Error(`Unknown log level: ${t}`) }(t); this.logger = new E(e) } else this.logger = new E(t); return this } withUrl(t, e) { return w.isRequired(t, "url"), w.isNotEmpty(t, "url"), this.url = t, this.httpConnectionOptions = "object" == typeof e ? { ...this.httpConnectionOptions, ...e } : { ...this.httpConnectionOptions, transport: e }, this } withHubProtocol(t) { return w.isRequired(t, "protocol"), this.protocol = t, this } withAutomaticReconnect(t) { if (this.reconnectPolicy) throw new Error("A reconnectPolicy has already been set."); return t ? Array.isArray(t) ? this.reconnectPolicy = new j(t) : this.reconnectPolicy = t : this.reconnectPolicy = new j, this } withServerTimeout(t) { return w.isRequired(t, "milliseconds"), this.Ve = t, this } withKeepAliveInterval(t) { return w.isRequired(t, "milliseconds"), this.Ke = t, this } withStatefulReconnect(t) { return void 0 === this.httpConnectionOptions && (this.httpConnectionOptions = {}), this.httpConnectionOptions._e = !0, this.Y = null == t ? void 0 : t.bufferSize, this } build() { const t = this.httpConnectionOptions || {}; if (void 0 === t.logger && (t.logger = this.logger), !this.url) throw new Error("The 'HubConnectionBuilder.withUrl' method must be called before building the connection."); const e = new K(this.url, t); return q.create(e, this.logger || f.instance, this.protocol || new Y, this.reconnectPolicy, this.Ve, this.Ke, this.Y) } } return Uint8Array.prototype.indexOf || Object.defineProperty(Uint8Array.prototype, "indexOf", { value: Array.prototype.indexOf, writable: !0 }), Uint8Array.prototype.slice || Object.defineProperty(Uint8Array.prototype, "slice", { value: function (t, e) { return new Uint8Array(Array.prototype.slice.call(this, t, e)) }, writable: !0 }), Uint8Array.prototype.forEach || Object.defineProperty(Uint8Array.prototype, "forEach", { value: Array.prototype.forEach, writable: !0 }), s })(), "object" == typeof exports && "object" == typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define([], e) : "object" == typeof exports ? exports.signalR = e() : t.signalR = e();
+//# sourceMappingURL=signalr.min.js.map
\ No newline at end of file
diff --git a/Tests/Program.cs b/Tests/Program.cs
new file mode 100644
index 0000000..9dd1472
--- /dev/null
+++ b/Tests/Program.cs
@@ -0,0 +1,102 @@
+using System.Text.Json;
+using System.Text;
+
+class ChessApiTest
+{
+ private static readonly HttpClient client = new HttpClient { BaseAddress = new Uri("https://localhost:7118/api/") };
+
+ static async Task Main()
+ {
+ Console.WriteLine("Starting Chess API Test...");
+
+ var gameId = await CreateGame();
+ var (player1Id, isWhite1) = await JoinGame();
+ var (player2Id, isWhite2) = await JoinGame();
+
+ await GetGameState(gameId);
+
+ var pawnId = "wPawn4";
+ await GetLegalMoves(gameId, pawnId);
+
+ await MakeMove(gameId, player1Id, pawnId, 6, 4, 4, 4); // e2 to e4
+
+ await MakeMove(gameId, player2Id, "bPawn4", 1, 4, 2, 4); // e7 to e6
+
+ await MakeMove(gameId, player1Id, "wKing", 7, 4, 7, 6); // Try castling
+
+ await MakeMove(gameId, player1Id, "wPawn4", 4, 4, 3, 4); // Move bishop
+
+ await MakeMove(gameId, player2Id, "bPawn3", 1, 3, 3, 3); // d7 to d5
+
+ await MakeMove(gameId, player1Id, "wPawn4", 4, 4, 2, 3); // En passant capture
+
+ await MakeMove(gameId, player1Id, "wPawn7", 6, 7, 7, 7, PieceType.Queen); // Pawn Promotion
+
+ await GetGameState(gameId);
+
+ Console.WriteLine("Test completed.");
+ }
+
+ private static async Task CreateGame()
+ {
+ var response = await client.PostAsync("Chess/new", null);
+ var data = JsonSerializer.Deserialize>(await response.Content.ReadAsStringAsync());
+
+ Guid gameId = Guid.Parse(data["gameId"].ToString());
+ Console.WriteLine($"Game created: {gameId}");
+ return gameId;
+ }
+
+ private static async Task<(Guid, bool)> JoinGame()
+ {
+ var response = await client.GetAsync("Chess/JoinGame");
+ var data = JsonSerializer.Deserialize>(await response.Content.ReadAsStringAsync());
+
+ Guid playerId = Guid.Parse(data["id"].ToString());
+ bool isWhite = bool.Parse(data["isWhite"].ToString());
+
+ Console.WriteLine($"Player joined: {playerId} (IsWhite: {isWhite})");
+ return (playerId, isWhite);
+ }
+
+ private static async Task GetGameState(Guid gameId)
+ {
+ var response = await client.GetAsync($"Chess/{gameId}");
+ Console.WriteLine($"Game state: {await response.Content.ReadAsStringAsync()}");
+ }
+
+ private static async Task GetLegalMoves(Guid gameId, string pieceId)
+ {
+ var response = await client.GetAsync($"Chess/{gameId}/legalMoves/{pieceId}");
+ Console.WriteLine($"Legal moves for {pieceId}: {await response.Content.ReadAsStringAsync()}");
+ }
+
+ private static async Task MakeMove(Guid gameId, Guid playerId, string pieceId, int sourceRow, int sourceCol, int targetRow, int targetCol, PieceType? promotion = null)
+ {
+ var payload = new
+ {
+ GameId = gameId,
+ PlayerId = playerId,
+ PieceId = pieceId,
+ SourceRow = sourceRow,
+ SourceCol = sourceCol,
+ TargetRow = targetRow,
+ TargetCol = targetCol,
+ PromotionChoice = promotion
+ };
+
+ var jsonPayload = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
+ var response = await client.PostAsync("Chess/move", jsonPayload);
+ Console.WriteLine($"Move {pieceId} to ({targetRow}, {targetCol}): {await response.Content.ReadAsStringAsync()}");
+ }
+}
+
+public enum PieceType
+{
+ Pawn,
+ Rook,
+ Knight,
+ Bishop,
+ Queen,
+ King
+}
\ No newline at end of file
diff --git a/Tests/Tests.csproj b/Tests/Tests.csproj
new file mode 100644
index 0000000..2150e37
--- /dev/null
+++ b/Tests/Tests.csproj
@@ -0,0 +1,10 @@
+
+
+
+ Exe
+ net8.0
+ enable
+ enable
+
+
+
+
+
+
+
+
+
+
+
-
-
\ No newline at end of file
+
+
+ Chess
++ As someone who loves chess, I wanted to create a chess game that I could play with my friends and family. This project is a work in progress, as currently it can only be played locally. It was built in C# on .NET 8.0, using winforms, because I like a challenge. I plan to add online multiplayer functionality in the future. +
+
+
+
+
+
+ Compiler
++ I love solving problems, and figuring out how things work. What better way to do both than writing a compiler myself? This project is a compiler that I wrote in C# on .NET 8.0. It takes in a simple language that I created, outputs the corresponding common intermediate language (CIL), and executes it. I plan to add more features in the future. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Chess
++ As someone who loves chess, I wanted to create a chess game that I could play with my friends and family. This project is a work in progress, as currently it can only be played locally. It was built in C# on .NET 8.0, using winforms, because I like a challenge. I plan to add online multiplayer functionality in the future. +
+
+
+
+
+
+
+
+
+@section Styles {
+
+
+
+
+
+}
+
+@section Scripts {
+
+
+
+}
\ No newline at end of file
diff --git a/JoshHeaps.Net/Pages/_Layout.cshtml b/JoshHeaps.Net/Pages/_Layout.cshtml
new file mode 100644
index 0000000..51ec811
--- /dev/null
+++ b/JoshHeaps.Net/Pages/_Layout.cshtml
@@ -0,0 +1,28 @@
+@{
+ Layout = null;
+ ViewData["cssVersion"] = "1.0.0"; // <--- change this once to bust cache
+}
+
+
+
+
+
+
+