Update documentation

Author: pklaschka

README.md

@@ -21,18 +21,18 @@ Create an `i18n.ts` file to configure your localization settings:
 
 ```typescript
 #!/usr/bin/env -S deno run --allow-read --allow-write=./locales/ --allow-env
-import { HonolateConfig, initHonolate, runCLI } from "@wuespace/honolate";
+import { initHonolate, InitHonolateOptions, runCLI } from "@wuespace/honolate";
 
-const config: HonolateConfig = {
-  defaultLocale: "en",
-  supportedLocales: {
+const config = {
+  defaultLanguage: "en",
+  languages: {
     en: import.meta.resolve("./locales/en.json"),
     de: import.meta.resolve("./locales/de.json"),
   },
-};
+} satisfies InitHonolateOptions<string>;
 
 // CLI
-import.meta.main && await runCLI(config, import.meta.dirname);
+import.meta.main && await runCLI(config, import.meta.dirname ?? Deno.cwd());
 
 // Middleware for Hono
 export const i18n = await initHonolate(config);
@@ -73,31 +73,16 @@ Deno.serve(app);
 You can use eager strings for immediate translation:
 
 ```typescript
-import { asFC, t } from "@wuespace/honolate";
+import { t } from "@wuespace/honolate";
 
-c.render(asFC(() => (
+c.render(
   <div>
     <h1>{t`Hello world!`}</h1>
     <p>{t`We can also use variables like ${new Date()}.`}</p>
-  </div>
-)));
+  </div>,
+);
 ```
 
-Note that the `t` function internally uses `useRequestContext` to access the
-current request context. For this to work, it can only be called inside a
-component rendered with the `jsxRenderer` middleware. Here, we use `asFC` to
-create a functional component out of an inline JSX expression.
-
-Internally, all `asFC` does is to create a functional component:
-
-```typescript
-function asFC<T>(Component: () => JSX.Element) {
-  return <Component />;
-}
-```
-
-With that, everything inside the function now has access to the request context.
-
 ### Lazy strings
 
 Sometimes, you need to define strings outside of a component context. In this
@@ -116,11 +101,11 @@ function:
 import { t } from "@wuespace/honolate";
 import { greeting } from "./greeting.ts";
 
-c.render(asFC(() => (
+c.render(
   <div>
     <h1>{t(greeting)}</h1>
-  </div>
-)));
+  </div>,
+);
 ```
 
 ### Updating localization files

lib/hono/t.ts

@@ -13,11 +13,10 @@ import type { LocalizedStringValue } from "./LocalizedStringValue.ts";
  *
  * Can be used as a template string tag or as a function with a LazyLocalizedString.
  *
- * Can only be called inside a functional component. To use this directly in route handlers,
- * use {@link asFC} to wrap the handler as a functional component.
- *
  * This cannot be used outside of Hono request context (e.g., in plain Deno scripts),
- * since it relies on the request context to provide the current language's localization map.
+ * since it relies on the request's localization context,
+ * set by {@link import("./initHonolate.ts").initHonolate},
+ * to provide the current language's localization map.
  *
  * @example Example as template string tag:
  * ```ts
@@ -33,15 +32,15 @@ import type { LocalizedStringValue } from "./LocalizedStringValue.ts";
  * const greeting = t(lls);
  * ```
  *
- * @example Using with asFC in route handler:
+ * @example Using in route handler:
  * ```ts
- * import { asFC, t } from '@wuespace/honolate';
+ * import { t } from '@wuespace/honolate';
  *
  * app.get('/greet', c => {
- *   return c.render(asFC(() => {
+ *   return c.render(
  *     const greeting = t`Hello ${c.req.param('name')}!`;
  *     return greeting;
- *   }));
+ *   });
  * });
  * ```
  */