🔧 fix: broken links & typos (#186)

* fix: broken links & typos

* fix: undo required code formatting

* fix: revert url-object

* chore: fix frontmatter ident

---------

Co-authored-by: bogeychan <[email protected]>
Co-authored-by: Fecony <[email protected]>

Author: 3 people

docs/at-glance.md

@@ -137,7 +137,7 @@ const app = new Elysia()
 export type App = typeof app
 ```
 
-And on your client side:
+And on your client-side:
 
 ```typescript
 // client.ts

docs/essential/path.md

@@ -57,9 +57,7 @@ For instance, we can extract the user ID from the pathname, we can do something
 ```typescript
 import { Elysia } from 'elysia'
 
-new Elysia()
-    .get('/id/:id', ({ params: { id } }) => id)
-    .listen(3000)
+new Elysia().get('/id/:id', ({ params: { id } }) => id).listen(3000)
 ```
 
 We create a dynamic path with `/id/:id` which tells Elysia to match any path up until `/id` and after it could be any value, which is then stored as **params** object.
@@ -128,9 +126,7 @@ However, when you need a value of the path to be more dynamic and capture the re
 Wildcard can capture the value after segment regardless of amount by using "\*".
 
 ```typescript
-new Elysia()
-    .get('/id/*', ({ params }) => params['*'])
-    .listen(3000)
+new Elysia().get('/id/*', ({ params }) => params['*']).listen(3000)
 ```
 
 Sending a request to the server should return the response as the following:

docs/essential/route.md

@@ -159,15 +159,15 @@ Any HTTP method that matches the path, will be handled as follows:
 
 ## 404
 
-If no path matches the defined routes, Elysia will pass the request to `error` lifecycle before returning a "NOT_FOUND" with an HTTP status of 404.
+If no path matches the defined routes, Elysia will pass the request to `error` life cycle before returning a "NOT_FOUND" with an HTTP status of 404.
 
 ::: tip
 HTTP Status is used to indicate the type of response. By default if everything is correct, the server will return a '200 OK' status code (If a route matches and there is no error, Elysia will return 200 as default)
 
 If the server fails to find any route to handle, like in this case, then the server shall return a '404 NOT FOUND' status code.
 :::
 
-For Elysia, we can handle a custom 404 error by returning a value from 'error` lifecycle like this:
+For Elysia, we can handle a custom 404 error by returning a value from 'error` life cycle like this:
 
 ```typescript
 import { Elysia } from 'elysia'
@@ -188,4 +188,4 @@ When navigating to your web server, you should see the result as follows:
 | /    | POST   | Route not found :\( |
 | /hi  | GET    | Route not found :\( |
 
-You can learn more about lifecycle and error handling in [Lifecycle Event](/essential/life-cycle) and [error handling](/life-cycle/on-error)
+You can learn more about life cycle and error handling in [Life Cycle Events](/essential/life-cycle#events) and [Error Handling](/life-cycle/on-error).

docs/integrations/astro.md

@@ -18,16 +18,18 @@ head:
 
 With [Astro Endpoint](https://docs.astro.build/en/core-concepts/endpoints/), we can run Elysia on Astro directly.
 
-1. Set **output** to **server** in **astro.config.mjs** 
+1. Set **output** to **server** in **astro.config.mjs**
+
 ```javascript
 // astro.config.mjs
-import { defineConfig } from 'astro/config';
+import { defineConfig } from 'astro/config'
 
 // https://astro.build/config
 export default defineConfig({
     output: 'server' // [!code ++]
 })
 ```
+
 2. Create **pages/[...slugs].ts**
 3. Create or import an existing Elysia server in **[...slugs].ts**
 4. Export the handler with the name of method you want to expose
@@ -53,7 +55,7 @@ Elysia will work normally as expected because of WinterCG compliance.
 We recommended running [Astro on Bun](https://docs.astro.build/en/recipes/bun) as Elysia is designed to be run on Bun
 
 ::: tip
-You can run Elysia server without running Astro on Bun thanks to WinterCG support. 
+You can run Elysia server without running Astro on Bun thanks to WinterCG support.
 
 However some plugins like **Elysia Static** may not work if you are running Astro on Node.
 :::
@@ -63,6 +65,7 @@ With this approach, you can have co-location of both frontend and backend in a s
 Please refer to [Astro Endppoint](https://docs.astro.build/en/core-concepts/endpoints/) for more information.
 
 ## Prefix
+
 If you place an Elysia server not in the root directory of the app router, you need to annotate the prefix to the Elysia server.
 
 For example, if you place Elysia server in **apps/api/[...slugs].ts**, you need to annotate prefix as **/api** to Elysia server.

docs/life-cycle/before-handle.md

@@ -38,8 +38,8 @@ import { validateSession } from '@services/users'
 new Elysia()
     .get('/', () => 'hi', {
         beforeHandle({ set, cookie: { session } }) {
-          if(!validateSession(session.value))
-                return set.status = 'Unauthorized'
+            if (!validateSession(session.value))
+                return (set.status = 'Unauthorized')
         }
     })
     .listen(3000)
@@ -53,6 +53,7 @@ The response should be listed as follows:
 | ✅           | Hi           |
 
 ## Guard
+
 When we need to apply the same before handle to multiple routes, we can use [guard](#guard) to apply the same before handle to multiple routes.
 
 ```typescript

docs/life-cycle/on-error.md

@@ -1,28 +1,31 @@
 ---
 title: Error Handling - ElysiaJS
 head:
-  - - meta
-    - property: 'og:title'
-      content: Error Handling - ElysiaJS
+    - - meta
+      - property: 'og:title'
+        content: Error Handling - ElysiaJS
 
-  - - meta
-    - name: 'description'
-      content: Execute when an error is thrown in any other life-cycle at least once. Designed to capture and resolve an unexpected error, it's recommended to use on Error in the following situation. To provide custom error message. Fail safe or an error handler or retrying a request. Logging and analytics.
+    - - meta
+      - name: 'description'
+        content: Execute when an error is thrown in any other life-cycle at least once. Designed to capture and resolve an unexpected error, it's recommended to use on Error in the following situation. To provide custom error message. Fail safe or an error handler or retrying a request. Logging and analytics.
 
-  - - meta
-    - property: 'og:description'
-      content: Execute when an error is thrown in any other life-cycle at least once. Designed to capture and resolve an unexpected error, it's recommended to use on Error in the following situation. To provide custom error message. Fail safe or an error handler or retrying a request. Logging and analytics.
+    - - meta
+      - property: 'og:description'
+        content: Execute when an error is thrown in any other life-cycle at least once. Designed to capture and resolve an unexpected error, it's recommended to use on Error in the following situation. To provide custom error message. Fail safe or an error handler or retrying a request. Logging and analytics.
 ---
 
 # Error Handling
+
 **On Error** is the only life-cycle event that is not always executed on each request, but only when an error is thrown in any other life-cycle at least once.
 
 Designed to capture and resolve an unexpected error, its recommended to use on Error in the following situation:
-- To provide custom error message
-- Fail safe or an error handler or retrying a request
-- Logging and analytic
+
+-   To provide custom error message
+-   Fail safe or an error handler or retrying a request
+-   Logging and analytic
 
 ## Example
+
 Elysia catches all the errors thrown in the handler, classifies the error code, and pipes them to `onError` middleware.
 
 ```typescript
@@ -44,6 +47,7 @@ It's important that `onError` must be called before the handler we want to apply
 :::
 
 For example, returning custom 404 messages:
+
 ```typescript
 import { Elysia, NotFoundError } from 'elysia'
 
@@ -55,24 +59,28 @@ new Elysia()
             return 'Not Found :('
         }
     })
-	.post('/', () => {
-		throw new NotFoundError();
-	})
+    .post('/', () => {
+        throw new NotFoundError()
+    })
     .listen(8080)
 ```
 
 ## Context
+
 `onError` Context is extends from `Context` with additional properties of the following:
-- error: Error object thrown
-- code: Error Code
+
+-   error: Error object thrown
+-   code: Error Code
 
 ### Error Code
+
 Elysia error code consists of:
-- NOT_FOUND
-- INTERNAL_SERVER_ERROR
-- VALIDATION
-- PARSE
-- UNKNOWN
+
+-   NOT_FOUND
+-   INTERNAL_SERVER_ERROR
+-   VALIDATION
+-   PARSE
+-   UNKNOWN
 
 By default, the thrown error code is `unknown`.
 
@@ -81,6 +89,7 @@ If no error response is returned, the error will be returned using `error.name`.
 :::
 
 ## Custom Error
+
 Elysia supports custom error both in the type-level and implementation level.
 
 To provide a custom error code, we can use `Eylsia.error` to add a custom error code, helping us to easily classify and narrow down the error type for full type safety with auto-complete as the following:
@@ -97,31 +106,33 @@ new Elysia()
         MyError
     })
     .onError(({ code, error }) => {
-        switch(code) {
+        switch (code) {
             // With auto-completion
             case 'MyError':
                 // With type narrowing
                 // Error is typed as CustomError
                 return error
         }
     })
-	.get('/', () => {
-		throw new MyError('Hello Error');
-	})
+    .get('/', () => {
+        throw new MyError('Hello Error')
+    })
 ```
 
 Properties of `error` code is based on the properties of `error`, the said properties will be used to classify the error code.
 
 ## Local Error
-Same as others life-cycle, we provide an error into an [scope](/new/essential/scope) using guard:
+
+Same as others life-cycle, we provide an error into an [scope](/essential/scope) using guard:
+
 ```typescript
 new Elysia()
     .get('/', () => 'Hello', {
         beforeHandle({ set, request: { headers } }) {
-            if(!isSignIn(headers)) {
+            if (!isSignIn(headers)) {
                 set.status = 401
 
-                throw new Error("Unauthorized")
+                throw new Error('Unauthorized')
             }
         },
         error({ error }) {

docs/life-cycle/overview.md

@@ -20,14 +20,15 @@ head:
 </script>
 
 # Life Cycle
+
 It's recommended that you have read [Essential life-cycle](/essential/life-cycle) for better understanding of Elysia's Life Cycle.
 
 Life Cycle allows us to intercept an important event at the predefined point allowing us to customize the behavior of our server as needed.
 
 Elysia's Life Cycle event can be illustrated as the following.
 ![Elysia Life Cycle Graph](/assets/lifecycle.webp)
 
-Below are the request lifecycle available in Elysia:
+Below are the request life cycle available in Elysia:
 
 <Deck>
     <Card title="Request" href="request">
@@ -62,6 +63,7 @@ Below are the request lifecycle available in Elysia:
 ---
 
 Every life-cycle could be apply at both:
+
 1. Local Hook (route)
 2. Global Hook