docs: clarify how to expire cookies with Path/Domain

Remove ExpireCookie method - the existing Cookie() method handles this
use case by setting Expires to fasthttp.CookieExpireDelete.

Updated documentation to show the recommended approach.

Fixes #2878

Author: darwin808

ctx_interface_gen.go

@@ -1211,7 +1211,7 @@ func Test_Ctx_Cookie_Invalid(t *testing.T) {
 		{Name: "i", Value: "b", Domain: "2001:db8::1"},                                // ipv6 not allowed
 		{Name: "p", Value: "b", Path: "\x00"},                                         // invalid path byte
 		{Name: "e", Value: "b", Expires: time.Date(1500, 1, 1, 0, 0, 0, 0, time.UTC)}, // invalid expires
-		// Note: Partitioned without Secure is auto-fixed (Secure=true set automatically per CHIPS spec)
+		{Name: "s", Value: "b", Partitioned: true},                                    // partitioned but not secure
 	}
 
 	for _, invalid := range cases {
@@ -4545,114 +4545,6 @@ func Test_Ctx_ClearCookie(t *testing.T) {
 	require.Contains(t, string(c.Response().Header.Peek(HeaderSetCookie)), "test2=; expires=")
 }
 
-// go test -run Test_Ctx_ExpireCookie
-func Test_Ctx_ExpireCookie(t *testing.T) {
-	t.Parallel()
-
-	testCases := []struct {
-		expectedStrs    []string
-		notExpectedStrs []string
-		name            string
-		cookie          Cookie
-	}{
-		{
-			name: "with path",
-			cookie: Cookie{
-				Name: "session",
-				Path: "/admin",
-			},
-			expectedStrs: []string{"session=;", "path=/admin", "expires="},
-		},
-		{
-			name: "with domain",
-			cookie: Cookie{
-				Name:   "auth",
-				Domain: "example.com",
-			},
-			expectedStrs: []string{"auth=;", "domain=example.com", "expires="},
-		},
-		{
-			name: "with path and domain",
-			cookie: Cookie{
-				Name:   "token",
-				Path:   "/api",
-				Domain: "example.com",
-			},
-			expectedStrs: []string{"token=;", "path=/api", "domain=example.com", "expires="},
-		},
-		{
-			name: "with secure and httponly",
-			cookie: Cookie{
-				Name:     "secure_cookie",
-				Path:     "/",
-				Secure:   true,
-				HTTPOnly: true,
-			},
-			expectedStrs: []string{"secure_cookie=;", "secure", "HttpOnly", "expires="},
-		},
-		{
-			name: "with SameSite Strict",
-			cookie: Cookie{
-				Name:     "csrf",
-				SameSite: CookieSameSiteStrictMode,
-			},
-			expectedStrs: []string{"csrf=;", "SameSite=Strict", "expires="},
-		},
-		{
-			name: "with SameSite Lax",
-			cookie: Cookie{
-				Name:     "lax_cookie",
-				SameSite: CookieSameSiteLaxMode,
-			},
-			expectedStrs: []string{"lax_cookie=;", "SameSite=Lax", "expires="},
-		},
-		{
-			name: "with SameSite None (should set Secure)",
-			cookie: Cookie{
-				Name:     "cross_site",
-				SameSite: CookieSameSiteNoneMode,
-			},
-			expectedStrs: []string{"cross_site=;", "SameSite=None", "secure", "expires="},
-		},
-		{
-			name: "with Partitioned (should set Secure)",
-			cookie: Cookie{
-				Name:        "partitioned_cookie",
-				Partitioned: true,
-			},
-			expectedStrs: []string{"partitioned_cookie=;", "Partitioned", "secure", "expires="},
-		},
-		{
-			name: "with SameSite Disabled (should not set SameSite)",
-			cookie: Cookie{
-				Name:     "disabled_samesite",
-				SameSite: CookieSameSiteDisabled,
-			},
-			expectedStrs:    []string{"disabled_samesite=;", "expires="},
-			notExpectedStrs: []string{"SameSite"},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			app := New()
-			c := app.AcquireCtx(&fasthttp.RequestCtx{})
-			defer app.ReleaseCtx(c)
-
-			c.Res().ExpireCookie(&tc.cookie)
-			setCookie := string(c.Response().Header.Peek(HeaderSetCookie))
-
-			for _, expected := range tc.expectedStrs {
-				require.Contains(t, setCookie, expected)
-			}
-			for _, notExpected := range tc.notExpectedStrs {
-				require.NotContains(t, setCookie, notExpected)
-			}
-		})
-	}
-}
-
 // go test -race -run Test_Ctx_Download
 func Test_Ctx_Download(t *testing.T) {
 	t.Parallel()

ctx_test.go

@@ -1760,8 +1760,7 @@ app.Get("/set", func(c fiber.Ctx) error {
 app.Get("/delete", func(c fiber.Ctx) error {
     c.Cookie(&fiber.Cookie{
         Name:     "token",
-        // Set expiry date to the past
-        Expires:  time.Now().Add(-(time.Hour * 2)),
+        Expires:  fasthttp.CookieExpireDelete, // Use fasthttp's built-in constant
         HTTPOnly: true,
         SameSite: "Lax",
     })
@@ -1770,59 +1769,22 @@ app.Get("/delete", func(c fiber.Ctx) error {
 })
 ```
 
-Alternatively, use `ExpireCookie` for a cleaner approach (see below).
-
-### ExpireCookie
-
-Expires a cookie by its cookie definition. This is useful when you need to expire a cookie that was set with a specific `Path` or `Domain`. The browser will only clear the cookie if the `Path` and `Domain` attributes match the original cookie.
-
-```go title="Signature"
-func (r fiber.Res) ExpireCookie(cookie *fiber.Cookie)
-```
+You can also use `c.Cookie()` to expire cookies with specific `Path` or `Domain` attributes:
 
 ```go title="Example"
 app.Get("/logout", func(c fiber.Ctx) error {
-    // Expire a cookie with specific path
-    c.Res().ExpireCookie(&fiber.Cookie{
-        Name: "session",
-        Path: "/admin",
-    })
-
-    // Expire a cookie with specific domain
-    c.Res().ExpireCookie(&fiber.Cookie{
-        Name:   "auth",
-        Domain: "example.com",
-    })
-
-    // Expire a cookie with path, domain, and security flags
-    c.Res().ExpireCookie(&fiber.Cookie{
-        Name:     "token",
-        Path:     "/api",
-        Domain:   "example.com",
-        Secure:   true,
-        HTTPOnly: true,
-    })
-
-    // Expire a cookie with SameSite attribute
-    c.Res().ExpireCookie(&fiber.Cookie{
-        Name:     "csrf",
-        SameSite: "Strict",
-    })
-
-    // Expire a partitioned cookie (CHIPS)
-    c.Res().ExpireCookie(&fiber.Cookie{
-        Name:        "embedded",
-        Partitioned: true,
+    // Expire a cookie with path and domain
+    c.Cookie(&fiber.Cookie{
+        Name:    "token",
+        Path:    "/api",
+        Domain:  "example.com",
+        Expires: fasthttp.CookieExpireDelete,
     })
 
     return c.SendStatus(fiber.StatusOK)
 })
 ```
 
-:::note
-Only the `Name`, `Path`, `Domain`, `Secure`, `HTTPOnly`, `SameSite`, and `Partitioned` fields are used from the Cookie struct. The `Value` and `Expires` fields are overwritten to expire the cookie.
-:::
-
 ### Cookie
 
 Sets a cookie.

docs/api/ctx.md

@@ -201,9 +201,6 @@ func (r *DefaultRes) Attachment(filename ...string) {
 
 // ClearCookie expires a specific cookie by key on the client side.
 // If no key is provided it expires all cookies that came with the request.
-//
-// Note: This method does not work for cookies with a specific Domain or Path.
-// For those cases, use ExpireCookie to specify the matching attributes.
 func (r *DefaultRes) ClearCookie(key ...string) {
 	request := &r.c.fasthttp.Request
 	response := &r.c.fasthttp.Response
@@ -218,56 +215,6 @@ func (r *DefaultRes) ClearCookie(key ...string) {
 	}
 }
 
-// ExpireCookie expires a cookie by its cookie definition.
-// This is useful when you need to expire a cookie that was set with a specific
-// Path or Domain. The browser will only clear the cookie if the Path and Domain
-// attributes match the original cookie.
-//
-// Only the Name, Path, Domain, Secure, HTTPOnly, SameSite, and Partitioned fields are used.
-// The Value and Expires fields are overwritten to expire the cookie.
-func (r *DefaultRes) ExpireCookie(cookie *Cookie) {
-	fcookie := fasthttp.AcquireCookie()
-	defer fasthttp.ReleaseCookie(fcookie)
-
-	fcookie.SetKey(cookie.Name)
-	fcookie.SetValue("")
-	fcookie.SetExpire(fasthttp.CookieExpireDelete)
-
-	if cookie.Path != "" {
-		fcookie.SetPath(cookie.Path)
-	}
-	if cookie.Domain != "" {
-		fcookie.SetDomain(cookie.Domain)
-	}
-
-	// Handle SameSite attribute
-	isSecure := cookie.Secure
-	switch {
-	case utils.EqualFold(cookie.SameSite, CookieSameSiteStrictMode):
-		fcookie.SetSameSite(fasthttp.CookieSameSiteStrictMode)
-	case utils.EqualFold(cookie.SameSite, CookieSameSiteNoneMode):
-		fcookie.SetSameSite(fasthttp.CookieSameSiteNoneMode)
-		isSecure = true // SameSite=None requires Secure
-	case utils.EqualFold(cookie.SameSite, CookieSameSiteLaxMode):
-		fcookie.SetSameSite(fasthttp.CookieSameSiteLaxMode)
-	case utils.EqualFold(cookie.SameSite, CookieSameSiteDisabled):
-		// SameSite explicitly disabled: do not set SameSite attribute
-	default:
-		// No SameSite attribute set
-	}
-
-	// Handle Partitioned attribute
-	if cookie.Partitioned {
-		fcookie.SetPartitioned(true)
-		isSecure = true // Partitioned requires Secure
-	}
-
-	fcookie.SetSecure(isSecure)
-	fcookie.SetHTTPOnly(cookie.HTTPOnly)
-
-	r.c.fasthttp.Response.Header.SetCookie(fcookie)
-}
-
 // RequestCtx returns *fasthttp.RequestCtx that carries a deadline
 // a cancellation signal, and other values across API boundaries.
 func (r *DefaultRes) RequestCtx() *fasthttp.RequestCtx {
@@ -302,11 +249,6 @@ func (r *DefaultRes) Cookie(cookie *Cookie) {
 		sameSite = http.SameSiteLaxMode
 	}
 
-	// Partitioned requires Secure=true per CHIPS spec
-	if cookie.Partitioned {
-		cookie.Secure = true
-	}
-
 	// create/validate cookie using net/http
 	hc := &http.Cookie{
 		Name:        cookie.Name,