Fix typos

Author: szepeviktor

_typos.toml

@@ -3,8 +3,14 @@
 [files]
 extend-exclude = ["*.json", "*.js", "static/*", "layouts/*", "assets/*", "i18n/*"]
 
+[default]
+extend-ignore-re = [
+    "mmaping files"
+]
+
 [default.extend-words]
 datas = "datas"
 mmaped = "mmaped"
 exten = "exten"
-invokable = "invokable"
+invokable = "invokable"
+typ = "typ"

content/en/blog/releases/Kitex/release-v043.md

@@ -18,7 +18,7 @@ description: >
 ### **Optimization**
 
 1. **Frugal Performance Optimization** : Support frugal precompile (pretouch) when new client or server, which is to reduce the impact of dynamic compilation on latency.
-2. **Connpool Optimiztion** : Refactor connection pool to improve the idle connections cleanup.
+2. **Connpool Optimization** : Refactor connection pool to improve the idle connections cleanup.
 
 ---
 

content/en/blog/releases/Kitex/release-v0_13_0.md

@@ -93,7 +93,7 @@ description: >
 
 [[#1725](https://github.com/cloudwego/kitex/pull/1725)] fix: code gen import issue for streamx mode, stream call judgement bug and set ttheader streaming as default
 
-[[#1727](https://github.com/cloudwego/kitex/pull/1727)] fix(tool): fix tool UseStdLib remains unexcepted lib issue
+[[#1727](https://github.com/cloudwego/kitex/pull/1727)] fix(tool): fix tool UseStdLib remains unexpected lib issue
 
 ### Refactor
 [[#1658](https://github.com/cloudwego/kitex/pull/1658)] refactor: streamx api to adapt both grpc and ttheader streaming protocol and provide more user-friendly interface

content/en/cooperation/shumei.md

@@ -250,7 +250,7 @@ Kitex 提供了一个很好的机制，叫**重试熔断**的机制，其中有
 
 **Thrift** **（C++）/ Fbthrift 服务的过载保护**
 
-> 基础服务层大多是计算密集型服务，CPU 利用率等不完全反应程序的负载，服务过载可能是 GPU 负载过高。 使用请求在队列中的平均等待时间（“queue time”）来计算服务的负载。之所以不选择请求的平均处理时间（“procss time”），是为了去除下游服务调用的影响。有时 process time 的增加并不代表当前服务过载了，而是请求依赖的下游服务过载。另一方面，请求的 process time 增加到一定程度，当前服务的资源也会逐渐耗尽，最终反应在 queue time 的增加上。
+> 基础服务层大多是计算密集型服务，CPU 利用率等不完全反应程序的负载，服务过载可能是 GPU 负载过高。 使用请求在队列中的平均等待时间（“queue time”）来计算服务的负载。之所以不选择请求的平均处理时间（“process time”），是为了去除下游服务调用的影响。有时 process time 的增加并不代表当前服务过载了，而是请求依赖的下游服务过载。另一方面，请求的 process time 增加到一定程度，当前服务的资源也会逐渐耗尽，最终反应在 queue time 的增加上。
 
 我们可以看下图，当我们整个 CPU 或者是 GPU 整体的负载较高的时候，它的排队时间就会去无限长。所以这里给我们一种启发的机制，也就是说我们设置一个最长的队列等待时间。因为刚才也说了，在整个微服务的框架下，我们一定要干的一件事情就是一定要有超时的机制，因为没有超时的机制最终可能导致整个系统都被焊住。所以我们这里针对于这个 Queue Time 设置一个 Timeout 的话，那就可以去保证我们这些计算密集能服务在它的排队时间，等到一定时间的时候我们就立即丢弃请求。
 

content/en/docs/hertz/tutorials/basic-feature/context/response.md

@@ -375,14 +375,14 @@ Use RequestContext.Response.Header to obtain the ResponseHeader object, this obj
 | `func (h *ResponseHeader) DelClientCookieBytes(key []byte)`                     | Remove the cookie from the client                                                                                                                                                                                                |
 | `func (h *ResponseHeader) SetConnectionClose(close bool)`                       | Set the `Connection: close` flag in the response header                                                                                                                                                                          |
 | `func (h *ResponseHeader) ConnectionClose() bool`                               | Determine if Connection: close is included                                                                                                                                                                                       |
-| `func (h *ResponseHeader) ContentEncoding() []byte`                             | Obtion Content-Encoding                                                                                                                                                                                                          |
+| `func (h *ResponseHeader) ContentEncoding() []byte`                             | Option Content-Encoding                                                                                                                                                                                                          |
 | `func (h *ResponseHeader) SetContentEncoding(contentEncoding string)`           | Set Content-Encoding                                                                                                                                                                                                             |
 | `func (h *ResponseHeader) SetContentEncodingBytes(contentEncoding []byte)`      | Set Content-Encoding                                                                                                                                                                                                             |
 | `func (h *ResponseHeader) SetCanonical(key, value []byte)`                      | Set the Header key value, assuming that the key is in canonical form                                                                                                                                                             |
 | `func (h *ResponseHeader) Server() []byte`                                      | Return the value with key `Server` in the header                                                                                                                                                                                 |
 | `func (h *ResponseHeader) SetServerBytes(server []byte)`                        | Set the key in the header to the value of Server                                                                                                                                                                                 |
 | `func (h *ResponseHeader) MustSkipContentLength() bool`                         | Determine if there is a response body (according to the HTTP/1.1 protocol, there is no response body when the response status codes are 1xx, 204, or 304)                                                                        |
-| `func (h *ResponseHeader) StatusCode() int`                                     | Obtion StatusCode                                                                                                                                                                                                                |
+| `func (h *ResponseHeader) StatusCode() int`                                     | Option StatusCode                                                                                                                                                                                                                |
 | `func (h *ResponseHeader) SetStatusCode(statusCode int)`                        | Set StatusCode                                                                                                                                                                                                                   |
 | `func (h *ResponseHeader) Len() int`                                            | Return the number of headers                                                                                                                                                                                                     |
 | `func (h *ResponseHeader) DisableNormalizing()`                                 | Disable the normalization of header name (capitalize the first letter and the first letter after the Em dash)                                                                                                                    |

content/en/docs/hertz/tutorials/third-party/middleware/casbin.md

@@ -174,7 +174,7 @@ middleware provide methods that perform authentication operation.
 method parameter format is as follows:
 
 ```go
-func (m *Middleware) exampleMiddlwareMethod(expression string, opts ...Option) app.HandlerFunc
+func (m *Middleware) exampleMiddlewareMethod(expression string, opts ...Option) app.HandlerFunc
 ```
 
 it contains **expression** and **opts** two params.

content/en/docs/hertz/tutorials/third-party/service_discovery/etcd.md

@@ -279,7 +279,7 @@ func main() {
     if err != nil {
         panic(err)
     }
-    r, err := etcd.NewEtcdResovler([]string{"127.0.0.1:2379"},
+    r, err := etcd.NewEtcdResolver([]string{"127.0.0.1:2379"},
         etcd.WithAuthOpt("root","123456"),
     )
     if err != nil {

content/en/docs/hertz/tutorials/third-party/service_discovery/redis.md

@@ -65,7 +65,7 @@ Sample code:
 
 ```go
 func main() {
-    r := redis.NewRedisRegistry("127.0.0.1:6379", redis.WithRereshInterval(5))
+    r := redis.NewRedisRegistry("127.0.0.1:6379", redis.WithRefreshInterval(5))
     // ...
     h := server.Default(
     server.WithHostPorts(addr),

content/en/docs/hertz/tutorials/third-party/service_discovery/servicecomb.md

@@ -353,7 +353,7 @@ func main() {
 
 ### NewSCResolver
 
-`NewSCReslover` uses service-comb to create a new service discovery center. It needs to pass in a custom client. The configuration of the service discovery center can be customized.
+`NewSCResolver` uses service-comb to create a new service discovery center. It needs to pass in a custom client. The configuration of the service discovery center can be customized.
 
 Function signature:
 

content/en/docs/kitex/Tutorials/advanced-feature/codec_frugal.md

@@ -193,7 +193,7 @@ Note:
 1. If Framed is not set, there may be issues:
    1. The server may not be able to decode with frugal without Payload Size (refer to: "Kitex Server -> Notes");
    2. The server won't reply with a `Framed` payload, thus the Client may also not be able to decode with frugal (no Payload Size again);
-2. If the target server does not support `Framed`, then don't use it; the client can encode without it, but if the response (from the server) is not Framed (i.e. with preprended payload size), the client may not be able to decode with Frugal (so in this case, do not use slim template);
+2. If the target server does not support `Framed`, then don't use it; the client can encode without it, but if the response (from the server) is not Framed (i.e. with prepended payload size), the client may not be able to decode with Frugal (so in this case, do not use slim template);
 3. `TTHeaderFramed` is an alternative (it's the BIT-OR result of `TTHeader | Framed`).
 
 ##### Example Code