Merge pull request #4 from wuespace/fix-typo

Fix typo of `Localyzed` to `Localized`

Author: pklaschka

lib/hono/LazyLocalyzedString.ts lib/hono/LazyLocalizedString.tslib/hono/LazyLocalyzedString.ts renamed to lib/hono/LazyLocalizedString.ts

@@ -1,4 +1,4 @@
-import type { LocalyzedStringValue } from "./LocalyzedStringValue.ts";
+import type { LocalizedStringValue } from "./LocalizedStringValue.ts";
 
 /**
  * A lazily evaluated localized string with a key and optional values for interpolation.
@@ -7,7 +7,7 @@ import type { LocalyzedStringValue } from "./LocalyzedStringValue.ts";
  *
  * Use the {@link import("lt.ts").lt} function to create instances of this type.
  */
-export type LazyLocalyzedString = {
+export type LazyLocalizedString = {
   /**
    * The localization key used to look up the localized string.
    */
@@ -17,5 +17,5 @@ export type LazyLocalyzedString = {
    *
    * `"{i}"` gets replaced by the i-th value in this array. `"\{i}"` can be used to escape the `"{"` character.
    */
-  values: LocalyzedStringValue[];
+  values: LocalizedStringValue[];
 };

lib/hono/LocalyzedStringValue.ts lib/hono/LocalizedStringValue.tslib/hono/LocalyzedStringValue.ts renamed to lib/hono/LocalizedStringValue.ts

@@ -1,10 +1,10 @@
 import type { FC } from "@hono/hono/jsx";
-import type { LazyLocalyzedString } from "./LazyLocalyzedString.ts";
+import type { LazyLocalizedString } from "./LazyLocalizedString.ts";
 
 /**
  * A value passed into a localized string for interpolation.
  *
- * This can be a string, number, or another {@link LazyLocalyzedString} for nested localization.
+ * This can be a string, number, or another {@link LazyLocalizedString} for nested localization.
  *
  * For example, given the localization entry:
  *
@@ -15,23 +15,23 @@ import type { LazyLocalyzedString } from "./LazyLocalyzedString.ts";
  * }
  * ```
  *
- * You could create a `LazyLocalyzedString` for `welcomeMessage` that includes another
- * `LazyLocalyzedString` for `greeting` as its first value:
+ * You could create a `LazyLocalizedString` for `welcomeMessage` that includes another
+ * `LazyLocalizedString` for `greeting` as its first value:
  *
  * ```ts
- * const lazyGreeting: LazyLocalyzedString = {
+ * const lazyGreeting: LazyLocalizedString = {
  *   localizationKey: "greeting",
  *   values: ["Alice"]
  * };
  *
- * const lazyWelcomeMessage: LazyLocalyzedString = {
+ * const lazyWelcomeMessage: LazyLocalizedString = {
  *   localizationKey: "welcomeMessage",
  *   values: [lazyGreeting]
  * };
  * ```
  */
-export type LocalyzedStringValue =
+export type LocalizedStringValue =
   | string
   | number
-  | LazyLocalyzedString
+  | LazyLocalizedString
   | ReturnType<FC>;

lib/hono/ensureLazyLocalizedString.ts

@@ -0,0 +1,21 @@
+import type { LazyLocalizedString } from "./LazyLocalizedString.ts";
+import type { LocalizedStringValue } from "./LocalizedStringValue.ts";
+import { lt } from "./lt.ts";
+
+/**
+ * Ensures that the input is a LazyLocalizedString.
+ *
+ * Can be applied to either a template string or an already existing LazyLocalizedString.
+ *
+ * @returns the input as a LazyLocalizedString
+ */
+export function ensureLazyLocalizedString(
+  input: TemplateStringsArray | LazyLocalizedString,
+  values: LocalizedStringValue[],
+): LazyLocalizedString {
+  if (Array.isArray(input)) {
+    return lt(input as TemplateStringsArray, ...values);
+  } else {
+    return input as LazyLocalizedString;
+  }
+}

lib/hono/ensureLazyLocalyzedString.ts

@@ -1,6 +1,6 @@
-import { Context } from "@hono/hono";
-import { HonolateContext } from "./HonolateContext.ts";
-import { InitHonolateOptions } from "./InitHonolateOptions.ts";
+import type { Context } from "@hono/hono";
+import type { HonolateContext } from "./HonolateContext.ts";
+import type { InitHonolateOptions } from "./InitHonolateOptions.ts";
 import { runLanguageDetector } from "./runLanguageDetector.ts";
 
 /**

lib/hono/ensureRequestLanguage.ts

@@ -1,10 +1,10 @@
 import { escapeKey } from "../common/escapeKey.ts";
-import type { LazyLocalyzedString } from "./LazyLocalyzedString.ts";
-import type { LocalyzedStringValue } from "./LocalyzedStringValue.ts";
+import type { LazyLocalizedString } from "./LazyLocalizedString.ts";
+import type { LocalizedStringValue } from "./LocalizedStringValue.ts";
 
 /**
- * A template tag function to create a {@link LazyLocalyzedString}.
- * @returns A {@link LazyLocalyzedString} representing the localization key and its values.
+ * A template tag function to create a {@link LazyLocalizedString}.
+ * @returns A {@link LazyLocalizedString} representing the localization key and its values.
  *
  * @example
  * ```ts
@@ -35,8 +35,8 @@ import type { LocalyzedStringValue } from "./LocalyzedStringValue.ts";
  */
 export function lt(
   strings: TemplateStringsArray,
-  ...values: LocalyzedStringValue[]
-): LazyLocalyzedString {
+  ...values: LocalizedStringValue[]
+): LazyLocalizedString {
   const escaped = strings.map(escapeKey);
   let localizationKey = "";
   for (let i = 0; i < escaped.length; i++) {

lib/hono/lt.ts

@@ -1,17 +1,17 @@
 import { raw } from "@hono/hono/html";
 import type { HtmlEscapedString } from "@hono/hono/utils/html";
 import { unescapeKey } from "../common/unescapeKey.ts";
-import { ensureLazyLocalyzedString } from "./ensureLazyLocalyzedString.ts";
+import { ensureLazyLocalizedString } from "./ensureLazyLocalizedString.ts";
 import { getLocalizationMap } from "./getLocalizationMap.ts";
-import type { LazyLocalyzedString } from "./LazyLocalyzedString.ts";
-import type { LocalyzedStringValue } from "./LocalyzedStringValue.ts";
+import type { LazyLocalizedString } from "./LazyLocalizedString.ts";
+import type { LocalizedStringValue } from "./LocalizedStringValue.ts";
 
 /**
  * Resolves a localized string based on the current localization map.
 
  * @returns the localized string with placeholders filled in
  *
- * Can be used as a template string tag or as a function with a LazyLocalyzedString.
+ * 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.
@@ -24,9 +24,9 @@ import type { LocalyzedStringValue } from "./LocalyzedStringValue.ts";
  * const greeting = t`greeting.hello.${userName}`;
  * ```
  *
- * @example Example with LazyLocalyzedString:
+ * @example Example with LazyLocalizedString:
  * ```ts
- * const lls: LazyLocalyzedString = {
+ * const lls: LazyLocalizedString = {
  *   localizationKey: "greeting.hello",
  *   values: [userName],
  * };
@@ -47,14 +47,14 @@ import type { LocalyzedStringValue } from "./LocalyzedStringValue.ts";
  */
 export function t(
   strings: TemplateStringsArray,
-  ...values: LocalyzedStringValue[]
+  ...values: LocalizedStringValue[]
 ): string | HtmlEscapedString;
 export function t(
-  string: string | LazyLocalyzedString,
+  string: string | LazyLocalizedString,
 ): string | HtmlEscapedString;
 export function t(
-  string: TemplateStringsArray | LazyLocalyzedString | string,
-  ...values: LocalyzedStringValue[]
+  string: TemplateStringsArray | LazyLocalizedString | string,
+  ...values: LocalizedStringValue[]
 ): string | HtmlEscapedString {
   if (typeof string === "string") {
     // simple string, return as is
@@ -63,7 +63,7 @@ export function t(
       values: [],
     };
   }
-  const lls = ensureLazyLocalyzedString(string, values);
+  const lls = ensureLazyLocalizedString(string, values);
   const localizationValues = getLocalizationMap();
 
   if (!(lls.localizationKey in localizationValues)) {

lib/hono/t.ts

@@ -5,5 +5,5 @@ export { t } from "./hono/t.ts";
 export { asFC } from "./hono/asFC.tsx";
 export { runCLI } from "./extract/runCLI.ts";
 export { useLocale } from "./hono/useLocale.ts";
-export type { LocalyzedStringValue } from "./hono/LocalyzedStringValue.ts";
-export type { LazyLocalyzedString } from "./hono/LazyLocalyzedString.ts";
+export type { LocalizedStringValue } from "./hono/LocalizedStringValue.ts";
+export type { LazyLocalizedString } from "./hono/LazyLocalizedString.ts";