fix: weight and translate

Author: ppzqh

content/en/docs/hertz/tutorials/basic-feature/_index.md

@@ -23,6 +23,8 @@ keywords:
     "Constants",
     "Render",
     "JSON Marshal Library",
+    "SSE",
+    "http.Handler adaptor",
   ]
 description: "Basic feature of Hertz."
 ---

content/en/docs/hertz/tutorials/basic-feature/http-adaptor.md

@@ -1,22 +1,25 @@
 ---
-title: "Hertz http.Handler adaptor"
+title: "http.Handler adaptor"
 date: 2025-05-21
-weight: 12
+weight: 20
 keywords: ["adaptor"]
-description: "Hertz http.Handler adaptor"
+description: ""
 ---
 
 ## Background
+
 - We will deprecate the Hertz's native file system
 - Provide an fs implementation that is both compatible and performs well, using the official net/http ecosystem.
 - Reduce the implementation of a large number of extensions by expanding the hertz function through the official net/http ecosystem
 
 ## What is adaptor.HertzHandler
+
 - You are allowed to directly convert your existing http.HandlerFunc method into a HertzHandler.
 - You can directly use http.FileServer, embed.FS, and other official ecosystems
 - You can even use this directly at Hertz github.com/gorilla/websocket
 
 ## Example
+
 ```go
 package main
 

content/en/docs/hertz/tutorials/basic-feature/sse.md

@@ -1,26 +1,30 @@
 ---
 title: "SSE"
 date: 2025-05-21
-weight: 12
+weight: 19
 keywords: ["SSE"]
-description: "Hertz Support SSE。"
+description: "SSE in Hertz"
 ---
 ```Code：https://github.com/cloudwego/hertz/tree/develop/pkg/protocol/sse```
 
 **Changelog**
+
 - 2025/05/15 Has been released to the open-source version v0.10.0
 - 2025/05/13 [d3c68463] Added Get / SetLastEventID.
 - 2025/05/13 [3952e956] The Reader ForEach interface supports passing in ctx.
 - 2025/04/24 [cf38573ce] First version completed
 
-## 什么是Server-Sent Events (SSE)
+## What is Server-Sent Events (SSE)
+
 - SSE is an HTML standard used to describe the implementation of the EventSource API in browsers. Strictly speaking, it is not an HTTP protocol.
 - Both the popular Model Context Protocol (MCP) and Agent2Agent (A2A) protocols are based to some extent on SSE
-    - https://www.anthropic.com/news/model-context-protocol
-    - https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/
+  - https://www.anthropic.com/news/model-context-protocol
+  - https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/
 
 ## Server Implementation
+
 ### Return data
+
 ```go
 import "github.com/cloudwego/hertz/pkg/protocol/sse"
 
@@ -31,73 +35,78 @@ func HandleSSE(ctx context.Context, c *app.RequestContext) {
         w.WriteEvent("id-x", "message", []byte("hello\n\nworld"))
         time.Sleep(10 * time.Millisecond)
     }
-    w.Close() // 发送最后的chunk数据，确保优雅退出。可选，Hertz 在 Handler 返回后会自动调用。
+    w.Close() // Send the last chunk of data to ensure graceful exit. Optional, Hertz will automatically call this after the Handler returns.
 
-    // 请确保 writer 的生命周期和handler一致。不要go异步后台使用。
+    // Please make sure that the lifecycle of the writer is consistent with that of the handler. Do not use it in asynchronous background.
 }
 ```
 
-
 ### FAQ
+
 #### connection has been closed when flush
-Reason: The client connection has been disconnected, possibly due to a long time without response data. Please check the corresponding configuration.
 
+Reason: The client connection has been disconnected, possibly due to a long time without response data. Please check the corresponding configuration.
 
 ## Client Implementation
 
 ### Initiate a request
+
 It's exactly the same as making a normal HTTP request to Hertz.
 Note: The new Hertz version will automatically recognize SSE streams, so you don't need to explicitly set `WithResponseBodyStream(true)`
 
 **Some optional headers**
+
 ```go
 import "github.com/cloudwego/hertz/pkg/protocol/sse"
 
-sse.AddAcceptMIME(req) // 部分SSE Server可能会要求显式增加 Accept: text/event-stream
-sse.SetLastEventID(req, "id-123") // 对于有状态服务，需要通过 SetLastEventID 告诉 Server
+sse.AddAcceptMIME(req) // Some SSE Servers may require explicit addition of Accept: text/event-stream
+sse.SetLastEventID(req, "id-123") // For stateful services, you need to tell the Server via SetLastEventID
 ```
 
 ### Handle response
+
 ```go
 import "github.com/cloudwego/hertz/pkg/protocol/sse"
 
 func HandleSSE(ctx context.Context, resp *protocol.Response) error {
     r, err := sse.NewReader(resp)
     if err != nil {
-    return err
+        return err
     }
-
-    // 也可以手动调用 r.Read 方法
+    
+    // You can also call the r.Read method manually
     err = r.ForEach(ctx, func(e *Event) error {
         println("Event:", e.String())
         return nil
     })
-    if err != nil { // 如果 Server 正常断开，这里 err == nil，不会报错
-        // 其他io错误 或 ctx cancelled
+    if err != nil { // If the Server is disconnected normally, err == nil here, no error will be reported
+        // Other io errors or ctx cancelled
         return err
     }
-    println("Client LastEventID", r.LastEventID()) // 可用于保存最后接收的 Event ID
+    println("Client LastEventID", r.LastEventID()) // Can be used to save the last received Event ID
     return nil
 }
 ```
 
 ### FAQ
 
 #### How to implement multi-level SSE/SSE Proxy?
+
 - You can refer to the implementations on both the Client and Server sides simultaneously
 - Enable `WithSenseClientDisconnection` in the server and pass the context to the next hop's Reader ForEach
-    - In this way, when the Client disconnects, it will be automatically recognized, and the entire stream will be interrupted
+  - In this way, when the Client disconnects, it will be automatically recognized, and the entire stream will be interrupted
 
 ## Event Struct
+
 ```go
 // Event represents a Server-Sent Event (SSE).
 type Event struct {
-    ID   string // 即 Event ID，sse.Reader 会自动记录最后的 Event ID，可使用 LastEventID() 获取
-    Type string // 即 Event Type，常见的如 "message"
-    Data []byte // 为了方便使用 Unmarshal/Marshal，这里使用 []byte，但是按spec这个字段必须要 utf8 string
+    ID string // Event ID, sse.Reader will automatically record the last Event ID, which can be obtained using LastEventID()
+    Type string // Event Type, such as "message"
+    Data []byte // []byte is used here for the convenience of Unmarshal/Marshal, but according to spec, this field must be utf8 string
 
-    // 不建议使用，主要是针对浏览器的 SourceEvent 返回该字段控制其重试策略。
-    // 如果使用Hertz作为Client可以参考：https://www.cloudwego.io/docs/hertz/tutorials/basic-feature/retry/
+    // Not recommended, mainly for the browser's SourceEvent to return this field to control its retry strategy.
+    // If you use Hertz as a client, you can refer to: https://www.cloudwego.io/docs/hertz/tutorials/basic-feature/retry/
     Retry time.Duration
 }
 ```

content/zh/docs/hertz/tutorials/basic-feature/_index.md

@@ -23,6 +23,8 @@ keywords:
     "常量",
     "渲染",
     "JSON Marshal 库",
+    "SSE",
+    "http.Handler adaptor",
   ]
 description: "Hertz 基本特性。"
 ---

content/zh/docs/hertz/tutorials/basic-feature/http-adaptor.md

@@ -1,22 +1,25 @@
 ---
-title: "Hertz http.Handler adaptor"
+title: "http.Handler adaptor"
 date: 2025-05-21
-weight: 12
+weight: 20
 keywords: ["adaptor"]
-description: "Hertz http.Handler adaptor"
+description: ""
 ---
 
 ## 背景
-- 主淘汰长期没有良好维护的 hertz 原生 fs 实现；
+
+- 淘汰长期没有良好维护的 hertz 原生 fs 实现；
 - 通过官方 net/http 生态提供一个兼容性较好，性能也不差的 fs 实现。
 - 通过官方 net/http 生态扩展 hertz 功能，减少大量扩展实现
 
 ## 什么是 adaptor.HertzHandler
+
 - 允许你将现有的 http.HandlerFunc 方法直接转为 HertzHandler
 - 可以直接使用 http.FileServer embed.FS 等官方生态
 - 甚至可以直接在 Hertz 使用 github.com/gorilla/websocket
 
 ## 具体例子
+
 ```go
 package main
 

content/zh/docs/hertz/tutorials/basic-feature/sse.md

@@ -1,26 +1,30 @@
 ---
 title: "SSE"
 date: 2025-05-21
-weight: 12
+weight: 19
 keywords: ["SSE"]
-description: "Hertz 提供的 SSE 能力。"
+description: "Hertz 提供的 SSE 能力"
 ---
 ```代码：https://github.com/cloudwego/hertz/tree/develop/pkg/protocol/sse```
 
 **Changelog**
+
 - 2025/05/15 已发布到开源版本 v0.10.0
 - 2025/05/13 [d3c68463] 增加 Get / SetLastEventID
 - 2025/05/13 [3952e956] Reader ForEach 接口支持传入 ctx
 - 2025/04/24 [cf38573ce] 第一版本完成
 
-## 什么是Server-Sent Events (SSE)
-- SSE是一个HTML标准，用于描述浏览器 EventSource API 的实现。严格说，不是http协议。
+## 什么是 Server-Sent Events (SSE)
+
+- SSE 是一个 HTML 标准，用于描述浏览器 EventSource API 的实现。严格说，不是 http 协议。
 - 流行的 Model Context Protocol (MCP) 或 Agent2Agent (A2A) 协议都一定程度基于 SSE
-    - https://www.anthropic.com/news/model-context-protocol
-    - https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/
+  - https://www.anthropic.com/news/model-context-protocol
+  - https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/
+
+## Server 端实现
 
-## Server端实现
 ### 返回数据
+
 ```go
 import "github.com/cloudwego/hertz/pkg/protocol/sse"
 
@@ -31,34 +35,37 @@ func HandleSSE(ctx context.Context, c *app.RequestContext) {
         w.WriteEvent("id-x", "message", []byte("hello\n\nworld"))
         time.Sleep(10 * time.Millisecond)
     }
-    w.Close() // 发送最后的chunk数据，确保优雅退出。可选，Hertz 在 Handler 返回后会自动调用。
+    w.Close() // 发送最后的 chunk 数据，确保优雅退出。可选，Hertz 在 Handler 返回后会自动调用。
 
-    // 请确保 writer 的生命周期和handler一致。不要go异步后台使用。
+    // 请确保 writer 的生命周期和 handler 一致。不要 go 异步后台使用。
 }
 ```
 
-
 ### 常见问题
+
 #### connection has been closed when flush
-原因：
-Client连接断开，可能是太久没有响应数据，请检查相应配置。
 
+原因：
+Client 连接断开，可能是太久没有响应数据，请检查相应配置。
 
-## Client端实现
+## Client 端实现
 
 ### 发起请求
-与正常 Hertz 发起一个普通的http请求完全一致。
-注意：新hertz版本会自动识别SSE流，不用显式设置 WithResponseBodyStream(true)
+
+与正常 Hertz 发起一个普通的 http 请求完全一致。
+注意：新 hertz 版本会自动识别 SSE 流，不用显式设置 WithResponseBodyStream(true)
 
 **部分可选 Header**
+
 ```go
 import "github.com/cloudwego/hertz/pkg/protocol/sse"
 
-sse.AddAcceptMIME(req) // 部分SSE Server可能会要求显式增加 Accept: text/event-stream
+sse.AddAcceptMIME(req) // 部分 SSE Server 可能会要求显式增加 Accept: text/event-stream
 sse.SetLastEventID(req, "id-123") // 对于有状态服务，需要通过 SetLastEventID 告诉 Server
 ```
 
 ### 处理返回
+
 ```go
 import "github.com/cloudwego/hertz/pkg/protocol/sse"
 
@@ -74,7 +81,7 @@ func HandleSSE(ctx context.Context, resp *protocol.Response) error {
         return nil
     })
     if err != nil { // 如果 Server 正常断开，这里 err == nil，不会报错
-        // 其他io错误 或 ctx cancelled
+        // 其他 io 错误 或 ctx cancelled
         return err
     }
     println("Client LastEventID", r.LastEventID()) // 可用于保存最后接收的 Event ID
@@ -85,20 +92,22 @@ func HandleSSE(ctx context.Context, resp *protocol.Response) error {
 ### 常见问题
 
 #### 如何实现多级的 SSE / SSE Proxy?
-- 可以同时参考  Client 端和 Server端的实现
+
+- 可以同时参考  Client 端和 Server 端的实现
 - Server 启用 `WithSenseClientDisconnection` 并且把 context 传入 下一跳的 Reader ForEach
-    - 这样当Client断开时，会自动识别，并且中断整个流
+  - 这样当 Client 断开时，会自动识别，并且中断整个流
 
 ## Event 结构体
+
 ```go
 // Event represents a Server-Sent Event (SSE).
 type Event struct {
     ID   string // 即 Event ID，sse.Reader 会自动记录最后的 Event ID，可使用 LastEventID() 获取
     Type string // 即 Event Type，常见的如 "message"
-    Data []byte // 为了方便使用 Unmarshal/Marshal，这里使用 []byte，但是按spec这个字段必须要 utf8 string
+    Data []byte // 为了方便使用 Unmarshal/Marshal，这里使用 []byte，但是按 spec 这个字段必须要 utf8 string
 
     // 不建议使用，主要是针对浏览器的 SourceEvent 返回该字段控制其重试策略。
-    // 如果使用Hertz作为Client可以参考：https://www.cloudwego.io/docs/hertz/tutorials/basic-feature/retry/
+    // 如果使用 Hertz 作为 Client 可以参考：https://www.cloudwego.io/docs/hertz/tutorials/basic-feature/retry/
     Retry time.Duration
 }
 ```