@optolith/entity-descriptions 0.2.1 → 0.3.1

package/lib/helpers/locale.d.ts

@@ -1,8 +1,27 @@
 import { Compare } from "@optolith/helpers/compare";
-import { Translate, TranslateMap } from "./translate.js";
+import type { LocaleMeasurementAdjustments } from "optolith-database-schema/gen";
+import { Translate, TranslateMap, type Format } from "./translate.js";
+/**
+ * The type of list to join in a locale-aware way.
+ */
+export type LocaleJoinType = "conjunction" | "disjunction" | "unit";
+/**
+ * The environment for a locale.
+ */
 export type LocaleEnvironment = {
     id: string;
+    format: Format;
     translate: Translate;
     translateMap: TranslateMap;
-    compare: Compare<string>;
+    compare: LocaleCompare;
+    join: (list: string[], type: LocaleJoinType) => string;
+    measurementAdjustments: Required<LocaleMeasurementAdjustments>;
 };
+/**
+ * A function that compares two strings according to the locale's sorting rules.
+ */
+export type LocaleCompare = Compare<string>;
+/**
+ * A function that joins a list of strings according to the locale's rules for the given type.
+ */
+export type LocaleJoin = (list: string[], type: LocaleJoinType) => string;

package/lib/helpers/translate.d.ts

@@ -1,14 +1,56 @@
-import { UI } from "optolith-database-schema/types/UI";
-import { LocaleMap } from "optolith-database-schema/types/_LocaleMap";
+import { Locale } from "optolith-database-schema/gen";
+import { ResponsiveTextSize } from "../entities/partial/responsiveText.js";
+/**
+ * The type of all translations
+ */
+export type Translations = NonNullable<Locale["translations"]>;
+/**
+ * A function that formats a string with the given arguments.
+ */
+export type Format = (text: string, args?: Record<string, unknown>) => string;
 /**
  * Translates a given key into a string, optionally with parameters.
  */
-export type Translate = <K extends keyof UI>(key: K, ...params: (string | number)[]) => string;
+export type Translate = <K extends keyof Translations>(key: K, ...rest: TranslationParamsInArray<K>) => string;
+/**
+ * Extracts the parameters for a given translation key, or never if the key does not have parameters.
+ */
+export type TranslationParams<K extends keyof Translations> = Translations[K] extends string & {
+    __params: infer Params;
+} ? Params : undefined;
+/**
+ * Extracts the parameters for a given translation key as an array, or an empty array if the key does not have parameters.
+ */
+export type TranslationParamsInArray<K extends keyof Translations> = Translations[K] extends string & {
+    __params: infer Params;
+} ? [params: Params] : [];
 /**
- * A mocked translate function.
+ * A dictionary of locale identifiers to other values.
  */
-export declare const translateMock: Translate;
+export type LocaleMap<T> = Record<string, T>;
 /**
  * Selects a value from a locale dictionary based on the selected locale.
  */
 export type TranslateMap = <T>(map: LocaleMap<T> | undefined) => T | undefined;
+/**
+ * The set of translation keys that do not have parameters.
+ */
+export type TranslationKeysWithoutParams = {
+    [K in keyof Translations]-?: Translations[K] extends string & {
+        __params: object;
+    } ? never : K;
+}[keyof Translations];
+/**
+ * Extracts the translation keys that match the parameters.
+ */
+export type TranslationKeyMatchingParams<Params> = Params extends object ? {
+    [K in keyof Translations]-?: keyof Params extends keyof TranslationParams<K> ? keyof TranslationParams<K> extends keyof Params ? K : never : never;
+}[keyof Translations] : TranslationKeysWithoutParams;
+/**
+ * Extracts the translation keys that match the parameters of the given key.
+ */
+export type TranslationKeyMatchingParamsOfKey<T extends keyof Translations> = Translations[T] extends object ? TranslationKeyMatchingParams<TranslationParams<T>> : TranslationKeysWithoutParams;
+/**
+ * Translates a key that has different translations based on the responsive text size, e.g. a full and a compressed version of the same translation.
+ */
+export declare const responsiveTranslate: <K extends keyof Translations, K2 extends TranslationKeyMatchingParamsOfKey<K>>(translate: Translate, responsiveTextSize: ResponsiveTextSize, fullKey: K, compressedKey: K2, ...rest: TranslationParamsInArray<K> & TranslationParamsInArray<K2>) => string;

package/lib/helpers/translate.js

@@ -1,8 +1,15 @@
-const insertParams = (str, params) => str.replace(/\{(?<index>\d+)\}/gu, (_match, _p1, _offset, _s, { index: rawIndex }) => {
-    const index = Number.parseInt(rawIndex, 10);
-    return params[index]?.toString() ?? `{${rawIndex}}`;
-});
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { ResponsiveTextSize } from "../entities/partial/responsiveText.js";
 /**
- * A mocked translate function.
+ * Translates a key that has different translations based on the responsive text size, e.g. a full and a compressed version of the same translation.
  */
-export const translateMock = (key, ...options) => insertParams(key, options);
+export const responsiveTranslate = (translate, responsiveTextSize, fullKey, compressedKey, ...rest) => {
+    switch (responsiveTextSize) {
+        case ResponsiveTextSize.Full:
+            return translate(fullKey, ...rest);
+        case ResponsiveTextSize.Compressed:
+            return translate(compressedKey, ...rest);
+        default:
+            return assertExhaustive(responsiveTextSize);
+    }
+};