typed-locales 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+import baseFormatters from './src/formatters';
+import type { Formatter } from './src/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 { initReact } from './src/react';

package/dist/index.js

@@ -1,4 +1,4 @@
-import baseFormatters from './formatters';
+import baseFormatters from './src/formatters';
 // Given a translations object returns a function that can be used to translate keys
 export const getTranslate = (translations, locale, extraFormatters) => {
     const formatters = { ...baseFormatters, ...extraFormatters };
@@ -80,3 +80,4 @@ export const getTranslate = (translations, locale, extraFormatters) => {
     }
     return translate;
 };
+export { initReact } from './src/react';

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "typed-locales",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Type safe utilities for translating strings",
-  "main": "index.js",
+  "main": "dist/index.js",
   "type": "module",
   "scripts": {
-    "build": "tsc",
+    "build": "rimraf dist && tsc",
     "dev": "tsx watch src/test.tsx"
   },
   "keywords": [],
@@ -15,6 +15,7 @@
   "dependencies": {
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
+    "rimraf": "^6.0.1",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3"
   },

package/dist/config.js

@@ -1,9 +0,0 @@
-import { initReact } from './react';
-import en from './translations/en';
-const customFormatters = {
-    myCustomFormatter: () => 'Hello im custom',
-};
-export const { useTranslation, TranslationProvider } = initReact({
-    en,
-    es: () => import('./translations/es').then(m => m.default),
-}, 'en', customFormatters);

package/dist/formatters.js

@@ -1,10 +0,0 @@
-const formatters = {
-    lowercase: (value) => value.toLowerCase(),
-    uppercase: (value) => value.toUpperCase(),
-    capitalize: (value) => value.charAt(0).toUpperCase() + value.slice(1),
-    void: () => '',
-    weekday: (value) => new Date(value).toLocaleDateString('en-US', { weekday: 'long' }),
-    number: (value) => value.toLocaleString(),
-    json: (value) => JSON.stringify(value),
-};
-export default formatters;

package/dist/react.js

@@ -1,53 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useState } from 'react';
-import { getTranslate } from './index';
-// Initial translation always should be loaded
-export const initReact = (translations, initialLocale, extraFormatters) => {
-    const TranslationContext = createContext(undefined);
-    const TranslationProvider = ({ children }) => {
-        const [locale, setLocale] = useState(initialLocale);
-        const [translate, setTranslate] = useState(() => getTranslate(translations[locale], locale, extraFormatters));
-        const [isLoading, setIsLoading] = useState(true);
-        const loadTranslation = async (targetLocale) => {
-            try {
-                const translationOrLoader = translations[targetLocale];
-                let translationData;
-                if (typeof translationOrLoader === 'function') {
-                    setIsLoading(true);
-                    translationData = await translationOrLoader();
-                }
-                else {
-                    translationData = translationOrLoader;
-                }
-                setTranslate(getTranslate(translationData, targetLocale, extraFormatters));
-            }
-            catch (error) {
-                console.error(`Failed to load translations for locale ${String(targetLocale)}:`, error);
-            }
-            finally {
-                setIsLoading(false);
-            }
-        };
-        return (_jsx(TranslationContext.Provider, { value: {
-                isLoading,
-                locale,
-                setLocale: async (newLocale) => {
-                    if (newLocale !== locale) {
-                        setLocale(newLocale);
-                        await loadTranslation(newLocale);
-                    }
-                },
-                t: translate,
-            }, children: children }));
-    };
-    const useTranslation = () => {
-        const context = useContext(TranslationContext);
-        if (!context)
-            throw new Error('useTranslation must be used within a TranslationProvider');
-        return context;
-    };
-    return {
-        TranslationProvider,
-        useTranslation
-    };
-};

package/dist/test.js

@@ -1,6 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useTranslation } from './config';
-const Test = () => {
-    const { t, locale, setLocale } = useTranslation();
-    return _jsxs("div", { children: [t('test'), t('nested.test', { translation: 'translated text' }), t('nested.deep.again', { value: 'someValue', otherValue: 'anotherValue' }), t('withValue', { value: 'myValue' }), t('multipleValues', { one: '1', two: '2', three: '3' }), t('examplePlural', { count: 0 }), t('examplePlural', { count: 1 }), t('examplePlural', { count: 5 }), t('examplePluralWithOtherValues', { count: 0, user: 'Alice', otherUser: undefined }), t('examplePluralWithOtherValues', { count: 1, user: 'Alice', otherUser: undefined }), t('examplePluralWithOtherValues', { count: 123, user: 'Alice', otherUser: 'Bob' }), t('exampleWithFormatting', { value: 'TEXT', other: 'Text' }), t('exampleWithJSONFormatter', { data: { key: 'value' } }), t('pluralWithNestedSubstitution', { count: 0, query: 'search', user: undefined }), t('pluralWithNestedSubstitution', { count: 1, query: 'search', user: 'john' }), t('pluralWithNestedSubstitution', { count: 5, query: 'search', user: 'john' }), t('mixedPluralNested', { count: 0, itemType: 'book', location: 'shelf' }), t('mixedPluralNested', { count: 1, itemType: 'book', location: 'shelf' }), t('mixedPluralNested', { count: 10, itemType: 'book', location: 'shelf' }), t('onlyFormat', { value: 'capitalize this' }), t('escapeBraces'), locale, _jsx("button", { onClick: () => setLocale('es'), children: "Change locale" })] });
-};

package/dist/translations/en.js

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

package/dist/translations/es.js

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

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../src/formatters.ts","../src/index.ts","../src/react.tsx","../src/test.tsx","../src/translations/en.ts","../src/translations/es.ts"],"errors":true,"version":"5.8.2"}

package/dist/validation.js

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