typed-locales 1.0.0 → 1.0.2

package/dist/formatters.d.ts

@@ -0,0 +1,11 @@
+export type Formatter = (value: string, locale: string) => string;
+declare const formatters: {
+    readonly lowercase: (value: string) => string;
+    readonly uppercase: (value: string) => string;
+    readonly capitalize: (value: string) => string;
+    readonly void: () => string;
+    readonly weekday: (value: string) => string;
+    readonly number: (value: string) => string;
+    readonly json: (value: string) => string;
+};
+export default formatters;

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+import baseFormatters from './formatters';
+import type { Formatter } from './formatters';
+type ValueType = null | number | string | undefined | object;
+export type BaseFormatters = keyof typeof baseFormatters;
+export type InternalDeepStringify<T> = {
+    [K in keyof T]: T[K] extends string ? string : T[K] extends object ? InternalDeepStringify<T[K]> : never;
+};
+export type DeepStringify<T> = RemoveReadonlyDeep<InternalDeepStringify<T>>;
+export type InternalRemoveReadonlyDeep<T> = {
+    -readonly [K in keyof T]: T[K] extends object ? InternalRemoveReadonlyDeep<T[K]> : T[K];
+};
+export type RemoveReadonlyDeep<T> = Simplify<InternalRemoveReadonlyDeep<T>>;
+type PluralSuffix = '_none' | '_one' | '_other';
+export type TranslationType = {
+    [key: string]: string | TranslationType;
+};
+type RemovePluralSuffix<T extends string> = T extends `${infer Base}${PluralSuffix}` ? Base : T;
+type PluralKeys<Base extends string> = `${Base}${PluralSuffix}`;
+type DotNestedLeafKeys<T> = {
+    [K in keyof T]: K extends string ? T[K] extends Record<string, any> ? `${K}.${DotNestedLeafKeys<T[K]>}` : RemovePluralSuffix<K> : never;
+}[keyof T];
+type GenerateStringFromProperties<T extends Record<string, any>> = T extends Record<string, never> ? string : `${string}{${keyof T & string}${string}` | `${string}{${keyof T & string}|${string}}${string}`;
+export type GenerateTranslationType<T> = {
+    -readonly [K in keyof T]: T[K] extends object ? Simplify<GenerateTranslationType<T[K]>> : GenerateStringFromProperties<InterpolationProperties<RemovePluralSuffix<T[K] & string>, IsPlural<T, RemovePluralSuffix<K & string>>>>;
+};
+type ExtractPlaceholders<T extends string> = T extends `${infer _Start}{${infer Placeholder}}${infer Rest}` ? (Placeholder extends `${infer Name}|${infer _Formatters}` ? Name : Placeholder) | ExtractPlaceholders<Rest> : never;
+type HasPluralKeys<T, Path extends string> = Path extends `${infer K}.${infer Rest}` ? K extends keyof T ? HasPluralKeys<T[K], Rest> : false : PluralKeys<Path> & keyof T extends never ? false : true;
+type IsPlural<T, Path extends string> = HasPluralKeys<T, Path>;
+type GetValue<T, Path extends string> = Path extends `${infer K}.${infer Rest}` ? K extends keyof T ? GetValue<T[K], Rest> : never : Path extends keyof T ? T[Path] : T[PluralKeys<Path> & keyof T];
+type InterpolationProperties<S extends string, IsPlural extends boolean> = IsPlural extends true ? {
+    count: number;
+} & {
+    [K in Exclude<ExtractPlaceholders<S>, 'count'>]: ValueType;
+} : ExtractPlaceholders<S> extends never ? {} : {
+    [K in ExtractPlaceholders<S>]: ValueType;
+};
+type InternalSimplify<T> = {
+    [K in keyof T]: InternalSimplify<T[K]>;
+} & {};
+type DeepOmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : T[K] extends Record<string, any> ? DeepOmitNever<T[K]> extends never ? never : K : K]: T[K] extends Record<string, any> ? DeepOmitNever<T[K]> : T[K];
+} extends infer U ? keyof U extends never ? never : U : never;
+export type Simplify<T> = InternalSimplify<DeepOmitNever<T>>;
+export declare const getTranslate: <Translations, ExtraFormattersType extends string = string, ExtraFormatters extends Record<ExtraFormattersType, Formatter> = Record<ExtraFormattersType, Formatter>>(translations: Translations, locale: string, extraFormatters?: ExtraFormatters) => <Key extends DotNestedLeafKeys<Translations>>(key: Key, ...arguments_: InterpolationProperties<GetValue<Translations, Key> & string, IsPlural<Translations, Key>> extends Record<string, never> ? [] : [params: Simplify<InterpolationProperties<GetValue<Translations, Key> & string, IsPlural<Translations, Key>>>]) => GetValue<Translations, Key>;
+export {};

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translations/en.d.ts

@@ -0,0 +1,28 @@
+declare const en: {
+    readonly test: "Regular translation";
+    readonly nested: {
+        readonly test: "Nested {translation|myCustomFormatter}";
+        readonly deep: {
+            readonly again: "Nested again with {value} and {otherValue}";
+        };
+    };
+    readonly withValue: "With value {value}";
+    readonly multipleValues: "Multiple values: {one}, {two}, and {three}";
+    readonly examplePlural_none: "No items available";
+    readonly examplePlural_one: "One item available";
+    readonly examplePlural_other: "{count} items available";
+    readonly examplePluralWithOtherValues_none: "No items for {user}";
+    readonly examplePluralWithOtherValues_one: "One item for {user}";
+    readonly examplePluralWithOtherValues_other: "{count} items for {user} and {otherUser}";
+    readonly exampleWithFormatting: "Formatted {value|uppercase} text and {other|lowercase}";
+    readonly exampleWithJSONFormatter: "JSON formatter: {data|json}";
+    readonly pluralWithNestedSubstitution_none: "No results found for {query}";
+    readonly pluralWithNestedSubstitution_one: "One result for {query} with {user|capitalize}";
+    readonly pluralWithNestedSubstitution_other: "{count} results for {query} by {user|capitalize}";
+    readonly mixedPluralNested_none: "No {itemType} in {location}";
+    readonly mixedPluralNested_one: "One {itemType} in {location|uppercase}";
+    readonly mixedPluralNested_other: "{count} {itemType}s in {location|uppercase}";
+    readonly onlyFormat: "Just formatting: {value|capitalize}";
+    readonly escapeBraces: "Braces like this: \\{notAKey\\}";
+};
+export default en;

package/dist/translations/es.d.ts

@@ -0,0 +1,28 @@
+declare const es: {
+    readonly test: "Traducción regular";
+    readonly nested: {
+        readonly test: "Anidado {translation|myCustomFormatter}";
+        readonly deep: {
+            readonly again: "Anidado nuevamente con {value} y {otherValue}";
+        };
+    };
+    readonly withValue: "Con valor {value}";
+    readonly multipleValues: "Múltiples valores: {one}, {two} y {three}";
+    readonly examplePlural_none: "No hay elementos disponibles";
+    readonly examplePlural_one: "Un elemento disponible";
+    readonly examplePlural_other: "{count} elementos disponibles";
+    readonly examplePluralWithOtherValues_none: "No hay elementos para {user}";
+    readonly examplePluralWithOtherValues_one: "Un elemento para {user}";
+    readonly examplePluralWithOtherValues_other: "{count} elementos para {user} y {otherUser}";
+    readonly exampleWithFormatting: "Texto formateado {value|uppercase} y {other|lowercase}";
+    readonly exampleWithJSONFormatter: "Formateador JSON: {data|json}";
+    readonly pluralWithNestedSubstitution_none: "No se encontraron resultados para {query}";
+    readonly pluralWithNestedSubstitution_one: "Un resultado para {query} con {user|capitalize}";
+    readonly pluralWithNestedSubstitution_other: "{count} resultados para {query} por {user|capitalize}";
+    readonly mixedPluralNested_none: "No hay {itemType} en {location}";
+    readonly mixedPluralNested_one: "Un {itemType} en {location|uppercase}";
+    readonly mixedPluralNested_other: "{count} {itemType}s en {location|uppercase}";
+    readonly onlyFormat: "Solo formateo: {value|capitalize}";
+    readonly escapeBraces: "Llaves como estas: \\{notAKey\\}";
+};
+export default es;

package/dist/validation.d.ts

@@ -0,0 +1,13 @@
+import type { BaseFormatters, RemoveReadonlyDeep } from ".";
+type ErrorMessage<Value extends string, T extends string> = `You are using an invalid formatter: ${T} in: "${Value}"`;
+type ExtractFormatter<T extends string> = T extends `${string}{${string}|${infer F}}${string}` ? F : never;
+type CountOpenBraces<T extends string, Count extends readonly unknown[] = []> = T extends `${infer First}${infer Rest}` ? First extends '{' ? CountOpenBraces<Rest, [...Count, unknown]> : CountOpenBraces<Rest, Count> : Count['length'];
+type CountCloseBraces<T extends string, Count extends readonly unknown[] = []> = T extends `${infer First}${infer Rest}` ? First extends '}' ? CountCloseBraces<Rest, [...Count, unknown]> : CountCloseBraces<Rest, Count> : Count['length'];
+type BalancedBraces<T extends string> = CountOpenBraces<T> extends CountCloseBraces<T> ? never : `Brackets are not balanced in: "${T}"`;
+type ValidateFormatter<T extends string, Formatters extends string> = ExtractFormatter<T> extends never ? BalancedBraces<T> : ExtractFormatter<T> extends Formatters ? BalancedBraces<T> : ErrorMessage<T, ExtractFormatter<T>>;
+type InternalValidateTranslation<T, Formatters extends string, KeyPath extends string = ''> = T extends Record<string, any> ? {
+    [K in keyof T]: InternalValidateTranslation<T[K], Formatters, KeyPath extends '' ? K & string : `${KeyPath}.${K & string}`>;
+} : T extends string ? ValidateFormatter<T, Formatters> : T;
+export type ValidateTranslation<T, Formatters extends string> = RemoveReadonlyDeep<InternalValidateTranslation<T, BaseFormatters | Formatters>>;
+export type EnsureValidTranslation<T extends never> = T;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typed-locales",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Type safe utilities for translating strings",
   "main": "index.js",
   "type": "module",