docs(v1/v2/v3): add Recommended Middleware and Vite Helper pages

Port Recommended Middleware and Vite Helper from inertiacore.net/docs/core
into all three versioned trees. The Advanced sidebars already reference
these slugs; without the files the build errors out.

Same body content across v1/v2/v3 with version-appropriate cross-reference
paths for CSRF Protection, Shared Data, and Error Handling — v1 has
csrf-protection under Advanced and shared-data under The Basics, while
v2/v3 have them under Security and Data & Props respectively.

Converted the upstream GitHub-flavored `> [!NOTE]` callout to <Note>,
which rewriteAsides maps to Starlight's native <Aside type="note">.

Author: adrum

v1/advanced/recommended-middleware.mdx

@@ -0,0 +1,158 @@
+---
+title: Recommended Middleware
+description: ASP.NET Core middleware InertiaCore recommends for the best experience.
+---
+
+ASP.NET Core makes several middleware available out of the box. We can also add a couple of our own to enhance the experience.
+
+InertiaCore recommends using the following middleware in your application:
+
+1. [CSRF Protection (recommended)](#csrf-protection)
+2. [Session (required)](#session)
+3. [HandleInertiaRequests (optional)](#handleinertiarequests)
+4. [Exception Handling (optional)](#exception-handling)
+
+## CSRF Protection
+
+We strongly recommend using the CSRF protection middleware. Please see the [CSRF Protection](/v1/advanced/csrf-protection) documentation for more information.
+
+## Session
+
+For the best experience, we recommend using the session middleware. The session middleware is used to store state in a session. This is useful for storing state between requests. This may be ModelState, flash messages, or other state that you need to persist between requests.
+
+```csharp
+// Program.cs
+
+// Add services to the container.
+builder.Services.AddControllersWithViews()
+    .AddSessionStateTempDataProvider();
+
+builder.Services.AddSession(options =>
+{
+    options.Cookie.Name = "App.Session";
+    options.Cookie.HttpOnly = true;
+    options.Cookie.IsEssential = true;
+    options.IdleTimeout = TimeSpan.FromMinutes(30);
+});
+builder.Services.AddInertia();
+builder.Services.AddViteHelper();
+
+// Later on...
+
+app.UseStaticFiles(); // For static files, like our CSS and JavaScript files
+app.UseRouting();
+app.UseSession();
+// app.UseAuthentication(); // If you have authentication
+// app.UseAuthorization(); // If you have authorization
+app.UseInertia();
+
+app.MapControllerRoute(
+    name: "default",
+    pattern: "{controller}/{action=Index}/{id?}");
+```
+
+## HandleInertiaRequests
+
+We recommend creating a custom HandleInertiaRequests middleware. This middleware is used to handle Inertia shared data on responses. This is helpful for flash messages, auth data, and other state that you want to include on every response. See the [Shared Data](/v1/the-basics/shared-data) documentation for more information.
+
+<Note>
+This middleware is not required, but it is recommended for the best experience.
+It's worth noting every Inertia response will include the shared data, so it's important to only include the data that you need. You may want to cache heavy queries or make them lazy/optional to avoid performance issues. You can then `JSON.parse` out the `data-page` attribute on the `#app` element to get the data you need from the initial page load.
+</Note>
+
+```csharp
+// Program.cs
+app.UseInertia();
+app.UseMiddleware<HandleInertiaRequests>();
+```
+
+```csharp
+// HandleInertiaRequests.cs
+using InertiaCore;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc.ViewFeatures;
+using Microsoft.EntityFrameworkCore;
+using App.Data;
+using App.Models;
+
+namespace App.Middleware;
+
+public class HandleInertiaRequests
+{
+    private readonly RequestDelegate _next;
+
+    public HandleInertiaRequests(RequestDelegate next)
+    {
+        _next = next;
+    }
+
+    public async Task InvokeAsync(HttpContext context)
+    {
+        Inertia.Share("flash", () =>
+        {
+            try
+            {
+                var factory = context.RequestServices.GetRequiredService<ITempDataDictionaryFactory>();
+                var tempData = factory.GetTempData(context);
+                var flash = new Dictionary<string, object>();
+
+                if (tempData.TryGetValue("error", out var error) && error is not null)
+                {
+                    // Ensure we only store simple serializable types
+                    flash.Add("error", error.ToString() ?? "");
+                }
+                if (tempData.TryGetValue("success", out var success) && success is not null)
+                {
+                    // Ensure we only store simple serializable types
+                    flash.Add("success", success.ToString() ?? "");
+                }
+                return flash;
+            }
+            catch (Exception)
+            {
+                // If there's any issue with TempData, return empty flash to prevent crashes
+                return new Dictionary<string, object>();
+            }
+        });
+
+        Inertia.Share("auth", () =>
+        {
+            if (context.User.Identity?.IsAuthenticated == true)
+            {
+                var userManager = context.RequestServices.GetRequiredService<UserManager<User>>();
+                var dbContext = context.RequestServices.GetRequiredService<ApplicationDbContext>();
+                var user = userManager.GetUserAsync(context.User).Result;
+                if (user != null)
+                {
+                    // Load the account data separately
+                    var account = dbContext.Accounts.Find(user.AccountId);
+
+                    return (object)new
+                    {
+                        user = new
+                        {
+                            id = user.Id,
+                            first_name = user.FirstName,
+                            last_name = user.LastName,
+                            email = user.Email,
+                            owner = user.Owner,
+                            account = new
+                            {
+                                id = user.AccountId,
+                                name = account?.Name
+                            }
+                        }
+                    };
+                }
+            }
+            return (object)new { user = (object?)null };
+        });
+
+        await _next(context);
+    }
+}
+```
+
+## Exception Handling
+
+We strongly recommend using the exception handling middleware. Please see the [Error Handling](/v1/advanced/error-handling) documentation for more information.

v1/advanced/vite-helper.mdx

@@ -0,0 +1,160 @@
+---
+title: Vite Helper
+description: Use the Vite helper to load your generated styles and scripts in InertiaCore.
+---
+
+A Vite helper class is available to automatically load your generated styles or scripts by simply using the `@Vite.Input("src/main.tsx")` helper. You can also enable HMR when using React by using the `@Vite.ReactRefresh()` helper. This pairs well with the `@inertiacore/vite-plugin` npm package.
+
+To get started with the Vite Helper, you will need to add one more line to the `Program.cs` or `Starup.cs` file.
+
+```csharp
+using InertiaCore.Extensions;
+
+[...]
+
+builder.Services.AddViteHelper();
+
+// Or with options (default values shown)
+
+builder.Services.AddViteHelper(options =>
+{
+    options.PublicDirectory = "wwwroot";
+    options.BuildDirectory = "build";
+    options.HotFile = "hot";
+    options.ManifestFilename = "manifest.json";
+});
+```
+
+Here are the default values for the Vite Plugin options:
+
+```ts
+import { defineConfig } from "vite";
+import inertiacore from "@inertiacore/vite-plugin";
+
+export default defineConfig({
+  plugins: [
+    //... other plugins,
+    inertiacore({
+      input: ["src/app.ts"],
+      refresh: true,
+    }),
+  ],
+});
+
+// Same as above, but with default values
+export default defineConfig({
+  plugins: [
+    //... other plugins,
+    inertiacore({
+      input: ["src/app.ts"],
+      refresh: true,
+      publicDirectory: "../wwwroot",
+      buildDirectory: "build",
+      hotFile: "hot",
+      manifestFilename: "manifest.json",
+    }),
+  ],
+});
+```
+
+## Examples
+
+Here's an example for a TypeScript React app with HMR:
+
+```html
+@using InertiaCore @using InertiaCore.Utils
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title inertia>My App</title>
+  </head>
+  <body>
+    @* This has to go first, otherwise preamble error *@ @Vite.ReactRefresh()
+    @await Inertia.Html(Model) @Vite.Input("src/main.tsx")
+  </body>
+</html>
+```
+
+with the corresponding `vite.config.js`, which is recommended to create in the `ClientApp` directory:
+
+```js
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import inertiacore from "@inertiacore/vite-plugin";
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [
+    inertiacore({
+      input: ["src/main.tsx"],
+    }),
+    react(),
+  ],
+  build: {
+    emptyOutDir: true,
+  },
+});
+```
+
+Here's an example for a TypeScript Vue app with Hot Reload:
+
+```html
+@using InertiaCore @using InertiaCore.Utils
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title inertia>My App</title>
+  </head>
+  <body>
+    @await Inertia.Html(Model) @Vite.Input("src/app.ts")
+  </body>
+</html>
+```
+
+with the corresponding `vite.config.js`, which is recommended to create in the `ClientApp` directory:
+
+```js
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import inertiacore from "@inertiacore/vite-plugin";
+
+export default defineConfig({
+  plugins: [
+    inertiacore({
+      input: ["src/app.ts"],
+      refresh: true,
+    }),
+    vue({
+      template: {
+        transformAssetUrls: {
+          base: null,
+          includeAbsolute: false,
+        },
+      },
+    }),
+  ],
+  build: {
+    emptyOutDir: true,
+  },
+});
+```
+
+Here's an example that just produces a single CSS file:
+
+```html
+@using InertiaCore @using InertiaCore.Utils
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  </head>
+  <body>
+    @await Inertia.Html(Model) @Vite.Input("src/main.scss")
+  </body>
+</html>
+```