@taon-dev/i18n 0.0.1

package/VERIFIED-BUILD-DATA.jsonc

@@ -0,0 +1,5 @@
+{
+  "commitHash": "bbd68061dd610554643c07f39ee5ef97cedd2d23",
+  "commitName": "chore: update",
+  "commitDate": "26-06-2026 22:43:54"
+}

package/assets/shared/shared_folder_info.txt

@@ -0,0 +1,7 @@
+THIS FILE IS GENERATED - DO NOT MODIFY
+
+Assets from this folder are being shipped with this npm package (@taon-dev/i18n)
+created from this project.
+
+THIS FILE IS GENERATED - DO NOT MODIFY
+          

package/bin/i18n

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S node --no-deprecation
+//#region @backend
+// --stack-trace-limit=10000
+require('./start');
+//#endregion

package/bin/i18n-debug

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S node --inspect --stack-trace-limit=10000 --no-deprecation
+//#region @backend
+// --stack-trace-limit=10000
+require('./start');
+//#endregion

package/bin/i18n-debug-brk

@@ -0,0 +1,4 @@
+#!/usr/bin/env -S node --inspect-brk --stack-trace-limit=10000 --no-deprecation
+//#region @backend
+require('./start');
+//#endregion

package/bin/start.js

@@ -0,0 +1,38 @@
+global.frameworkName = 'i18n';
+Error.stackTraceLimit = 100;
+global.i0 = {
+  defineInjectable: function () { }
+}
+const process= require('process');
+global.currentTaonScriptStartDateTime =  process.hrtime.bigint();
+
+process.removeAllListeners('warning');
+var argv = process.argv;
+
+global.hideLog = true;
+global.verboseLevel = 0;
+var verboseLevel = argv.find(a => a.startsWith('-verbose='));
+if (typeof verboseLevel !== 'undefined') {
+  global.hideLog = false;
+  verboseLevel = Number(verboseLevel.replace('-verbose=', ''));
+  if (!isNaN(verboseLevel)) {
+    global.verboseLevel = verboseLevel;
+  }
+  argv = argv.filter(a => !a.startsWith('-verbose='));
+}
+
+if (argv.includes('-verbose')) {
+  global.hideLog = false;
+  argv = argv.filter(a => a !== '-verbose');
+}
+
+const fs = require('fs');
+const path = require('path');
+var pathToCliJS = {
+  distDev: path.join(__dirname, '../dist/cli.js'),
+  localOrNPm: path.join(__dirname, '../cli.js')
+}
+var p = fs.existsSync(pathToCliJS.distDev) ? pathToCliJS.distDev : pathToCliJS.localOrNPm;
+global.globalSystemToolMode = true;
+var run = require(p).startCli;
+run(argv,__filename);

package/browser/README.md

@@ -0,0 +1,24 @@
+# MyLib
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.2.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project my-lib` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project my-lib`.
+> Note: Don't forget to add `--project my-lib` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build my-lib` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build my-lib`, go to the dist folder `cd dist/my-lib` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test my-lib` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/browser/fesm2022/i18n-browser.mjs

@@ -0,0 +1,521 @@
+import * as i0 from '@angular/core';
+import { inject, EnvironmentInjector, signal, computed, runInInjectionContext, untracked, resource, Injectable, InjectionToken, makeEnvironmentProviders, provideAppInitializer, PLATFORM_ID, effect, DOCUMENT } from '@angular/core';
+import { isPlatformBrowser, isPlatformServer } from '@angular/common';
+import { Title } from '@angular/platform-browser';
+import { TitleStrategy, Router } from '@angular/router';
+
+// THIS FILE IS GENERATED - DO NOT MODIFY
+/**
+ *  Autogenerated by current cli tool
+ */
+const BUILD_FRAMEWORK_CLI_NAME = 'tnp';
+/**
+ *  This value can be change in taon.jsonc (appId)
+ */
+const APP_ID = 'com.domain.example.i18n';
+/**
+ *  Autogenerated by current cli tool
+ */
+const BUILD_BASE_HREF = '';
+/**
+ *  This value can be change in taon.jsonc (overrideNpmName)
+ */
+const PROJECT_NPM_NAME = '@taon-dev/i18n';
+/**
+ * Taon version from you project taon.json
+ */
+const CURRENT_PACKAGE_TAON_VERSION = 'v21';
+/**
+ *  Autogenerated by current cli tool. Use *tnp release* to bump version.
+ */
+const CURRENT_PACKAGE_VERSION = '0.0.1';
+// THIS FILE IS GENERATED - DO NOT MODIFY
+
+const INTERNAL_TRANSIGNAL_CONFIG = Symbol('INTERNAL_TRANSIGNAL_CONFIG');
+const TREE_SHAKED_TRANSLATIONS = Symbol('TREE_SHAKED_TRANSLATIONS');
+
+//#region tnp-helpers cli template
+// import { Helpers, BaseCommandLineFeature } from 'tnp-helpers/src';
+// import { BaseProject, BaseStartConfig } from 'tnp-helpers/src'; // @backend
+// class $Version extends BaseCommandLineFeature<{}> {
+//   public _() {
+//     console.log(`Hello world from cli`);
+//     this._exit();
+//   }
+// }
+//#endregion
+/**
+ *
+ * @param argsv process.argsv
+ * @param filename needed if you want ipc communicaiton
+ */
+async function startCli(argsv, filename) {
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    return (void 0);
+}
+
+/**
+ * Param handler which allows for specification of basic params: `{name}`
+ *
+ * @param translation Translated text
+ * @param params      Params provided to translation function
+ */
+const simpleParamsHandler = (translation, params) => {
+    if (!params)
+        return translation;
+    for (const [key, value] of Object.entries(params)) {
+        translation = translation.replaceAll(`{${key}}`, simpleParamValueStringify(value));
+    }
+    return translation;
+};
+const noParamsHandler = translation => translation;
+const simpleParamValueStringify = (paramValue) => {
+    if (typeof paramValue === 'string') {
+        return paramValue;
+    }
+    if (paramValue == null) {
+        return '';
+    }
+    return paramValue.toString();
+};
+
+/**
+ * Main transignal service, used to process and cache translations
+ * Can be injected directly or with use of transignal object created with {@link prepareTransignal} function (recommended)
+ */
+class TransignalService {
+    constructor() {
+        this.injector = inject(EnvironmentInjector);
+        this.config = injectTransignalConfig();
+        this.paramsHandler = this.config.paramHandler ?? simpleParamsHandler;
+        this.loadingFn = this.config.loadingFn ?? (() => '...');
+        // eslint-disable-next-line no-console
+        this.errorHandler = this.config.errorHandler ?? console.error; // TODO maybe add a link to error page in docs
+        this.loadingCount = signal(0, ...(ngDevMode ? [{ debugName: "loadingCount" }] : []));
+        this.scopeMap = new Map();
+        this.languageMap = new Map();
+        /**
+         * Use to set or get active language
+         */
+        this.activeLang = signal(this.config.defaultLang, ...(ngDevMode ? [{ debugName: "activeLang" }] : []));
+        /**
+         * Use to determine whether service is currently loading translation files
+         */
+        this.isLoading = computed(() => this.loadingCount() > 0, ...(ngDevMode ? [{ debugName: "isLoading" }] : []));
+    }
+    t(scope) {
+        const existing = this.scopeMap.get(scope);
+        if (existing) {
+            return existing;
+        }
+        const scopeObj = this.initT(scope);
+        this.scopeMap.set(scope, scopeObj);
+        return scopeObj;
+    }
+    initT(scope) {
+        const cache = new Map();
+        const t = ((key, params) => {
+            const lang = this.activeLang();
+            const baseKey = `${lang}/${key}`;
+            const memoKey = params ? `${baseKey}_${JSON.stringify(params)}` : baseKey;
+            const alreadyComputed = cache.get(memoKey);
+            if (alreadyComputed) {
+                return alreadyComputed;
+            }
+            const { isLoading, error, value } = this.fetchLanguage(scope, lang);
+            if (isLoading()) {
+                return this.loadingFn?.(key);
+            }
+            if (error() || !value()) {
+                this.errorHandler('missing_file', error());
+                return '';
+            }
+            const result = this.replaceParams(this.resolveObjectPath(value(), key), params);
+            cache.set(memoKey, result);
+            return result;
+        }); // needed as other props are assigned below
+        t.arr = t;
+        t.obj = t;
+        t.prefix = this.preparePrefixFn(t, 1);
+        t.plural = this.preparePluralFn(t);
+        t.select = this.prepareSelectFn(t);
+        return t;
+    }
+    preparePrefixFn(t, depth) {
+        return (prefix) => {
+            const prefixedT = (key, params) => t(`${prefix}.${key}`, params);
+            prefixedT.arr = prefixedT;
+            prefixedT.obj = prefixedT;
+            prefixedT.plural = this.preparePluralFn(prefixedT);
+            prefixedT.select = this.prepareSelectFn(prefixedT);
+            prefixedT.prefix =
+                this.config.maxPrefixDepth || 3 >= depth
+                    ? this.preparePrefixFn(prefixedT, depth + 1)
+                    : () => {
+                        this.errorHandler('prefix_too_deep');
+                        const t = () => '';
+                        t.arr = () => [];
+                        t.obj = () => ({});
+                        t.plural = () => '';
+                        return t;
+                    };
+            return prefixedT;
+        };
+    }
+    preparePluralFn(t) {
+        return (key, count, params) => {
+            const plurals = t(key, { count, ...params });
+            if (typeof plurals === 'string') {
+                if (plurals === this.loadingFn(key)) {
+                    return plurals;
+                }
+                this.errorHandler('invalid_plural', key, plurals);
+                return plurals;
+            }
+            if (plurals[count]) {
+                return plurals[count];
+            }
+            const valueLastDigit = +count.toFixed(0).at(-1);
+            if (plurals.one && valueLastDigit === 1) {
+                return plurals.one;
+            }
+            if (plurals.many && valueLastDigit >= 5) {
+                return plurals.many;
+            }
+            if (plurals.few && valueLastDigit > 1 && valueLastDigit < 5) {
+                return plurals.few;
+            }
+            if (plurals.other) {
+                return plurals.other;
+            }
+            this.errorHandler('missing_plural', key, plurals, count);
+            return '';
+        };
+    }
+    prepareSelectFn(t) {
+        return (key, value, params) => {
+            const selects = t(key, { value, ...params });
+            if (typeof selects === 'string') {
+                if (selects === this.loadingFn(key)) {
+                    return selects;
+                }
+                this.errorHandler('invalid_select', key, selects);
+                return selects;
+            }
+            if (value !== null) {
+                if (selects[value]) {
+                    return selects[value];
+                }
+            }
+            else if (selects['null']) {
+                return selects['null'];
+            }
+            this.errorHandler('missing_select', key, selects, value);
+            return '';
+        };
+    }
+    replaceParams(translation, params) {
+        if (!translation)
+            return translation;
+        if (typeof translation === 'string') {
+            return this.paramsHandler(translation, params);
+        }
+        if (Array.isArray(translation)) {
+            return translation.map(val => this.replaceParams(val, params));
+        }
+        if (typeof translation === 'object') {
+            return Object.entries(translation).reduce((prev, [objKey, objVal]) => {
+                prev[objKey] = this.replaceParams(objVal, params);
+                return prev;
+            }, {});
+        }
+        return translation;
+    }
+    fetchLanguage(scope, lang) {
+        const cacheKey = `${scope}/${lang}`;
+        const existing = this.languageMap.get(cacheKey);
+        if (existing)
+            return existing;
+        const { translations, loader } = this.config;
+        const translation = runInInjectionContext(this.injector, () => translations === TREE_SHAKED_TRANSLATIONS
+            ? untracked(() => resource({
+                loader: async () => {
+                    this.loadingCount.update(count => ++count);
+                    const file = await runInInjectionContext(this.injector, () => loader(scope, lang));
+                    this.loadingCount.update(count => --count);
+                    return file;
+                },
+            }))
+            : {
+                value: signal(translations[scope]),
+                isLoading: signal(false),
+                error: signal(undefined),
+            });
+        this.languageMap.set(cacheKey, translation);
+        return translation;
+    }
+    resolveObjectPath(obj, path) {
+        const keys = path.split('.');
+        let current = obj;
+        for (const key of keys) {
+            if (current && typeof current === 'object') {
+                current = current[key];
+            }
+            else {
+                this.errorHandler('missing_key', { obj, path });
+                return undefined;
+            }
+        }
+        return current;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: TransignalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: TransignalService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.9", ngImport: i0, type: TransignalService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Utility function to define a type of translations for type inference
+ */
+const treeShakedTranslations = () => TREE_SHAKED_TRANSLATIONS;
+const TRANSIGNAL_CONFIG = new InjectionToken('TRANSIGNAL_CONFIG');
+/**
+ * Use to inject transignal config
+ */
+const injectTransignalConfig = () => inject(TRANSIGNAL_CONFIG);
+/**
+ * Prepares type-safe transignal object
+ * @param config Transignal configruation {@link TransignalConfig}
+ * @param features Extra tree-shakeable features
+ * - {@link withPreloadScopes} - preloads selected scopes
+ * - {@link withServerSideLanguage} - sets language based on `document.lang` in SSR environment
+ * - {@link withNavigatorLanguage} - sets language based on `navigator.language` in browser environment
+ * - {@link withLanguageLocalStorageSync} - syncs language with localStorage
+ * - {@link withTranslatedTitle} - enables translation of page title
+ */
+const prepareTransignal = (config, ...features) => {
+    const service = () => inject(TransignalService);
+    return {
+        [INTERNAL_TRANSIGNAL_CONFIG]: { config, features },
+        provide: () => makeEnvironmentProviders([
+            { provide: TRANSIGNAL_CONFIG, useValue: config },
+            TransignalService,
+            features.map(feature => feature.providers),
+        ]),
+        service,
+        t: (scope) => service().t(scope),
+    };
+};
+
+/**
+ * Provides unit-test version of transignal that loads translation instantly without loading
+ *
+ * @param transignal   existing transignal instance
+ * @param translations real translations in a selected language
+ */
+const provideTransignalTesting = (transignal, translations) => prepareTransignal({ ...transignal[INTERNAL_TRANSIGNAL_CONFIG].config, translations }, ...transignal[INTERNAL_TRANSIGNAL_CONFIG].features).provide();
+
+/**
+ * Utility to create a plural translation that can differ between languages and includes variants of translations for different plurals
+ * Can be used with {@link TranslateObj.plural}
+ * Translations may use automatic param: `{count}`
+ * @param translation plural translation object
+ */
+const plural = (translation) => translation;
+/**
+ * Utility to create a select translation
+ * Can be used with {@link TranslateObj.select}
+ * Translations may use automatic param: `{value}`
+ * @param translation select translation object
+ */
+const select = (translation) => translation;
+
+/**
+ * Saves user selected language in selected storage e.g. localStorage
+ * Works only in browser environment
+ *
+ * @param key Key under which it should save the language in storage
+ * @param storage Storage to be used e.g. localStorage or sessionStorage
+ */
+const withLanguageLocalStorageSync = (key = 'LANG', storage = 'localStorage') => {
+    return {
+        providers: [
+            provideAppInitializer(() => {
+                if (isPlatformBrowser(inject(PLATFORM_ID))) {
+                    const transignalService = inject(TransignalService);
+                    const store = window[storage];
+                    const savedLanguage = store.getItem(key);
+                    if (savedLanguage) {
+                        const { availableLangs } = injectTransignalConfig();
+                        if (availableLangs.includes(savedLanguage)) {
+                            transignalService.activeLang.set(savedLanguage);
+                        }
+                    }
+                    effect(() => {
+                        const updatedLang = transignalService.activeLang();
+                        store.setItem(key, updatedLang);
+                    });
+                }
+            }),
+        ],
+    };
+};
+
+/**
+ * Sets active language depending on `navigator.language`, which represents user defined browser settings
+ * Works only in browser environment
+ */
+const withNavigatorLanguage = () => {
+    return {
+        providers: [
+            provideAppInitializer(() => {
+                if (isPlatformBrowser(inject(PLATFORM_ID))) {
+                    const transignalService = inject(TransignalService);
+                    const { availableLangs } = injectTransignalConfig();
+                    const preferredLanguage = navigator.languages.map(language => language.split('-')[0].toLowerCase()).find(language => availableLangs.includes(language));
+                    if (preferredLanguage) {
+                        transignalService.activeLang.set(preferredLanguage);
+                    }
+                }
+            }),
+        ],
+    };
+};
+
+/**
+ * Preloads selected scopes in default language
+ * Use after language init by {@link withServerSideLanguage} or {@link withNavigatorLanguage}
+ * @param scopes Scopes which should be preloaded
+ */
+const withPreloadScopes = (scopes) => {
+    return {
+        providers: [
+            provideAppInitializer(() => {
+                const transignalService = inject(TransignalService);
+                effect(() => {
+                    const _activeLang = transignalService.activeLang();
+                    scopes.forEach(scope => transignalService.t(scope)(''));
+                });
+            }),
+        ],
+    };
+};
+
+/**
+ * Sets active language depending on `document.lang` attribute which should be set by the server.ts depending on `Accept-language` header
+ * Works only in SSR environment
+ */
+const withServerSideLanguage = () => {
+    return {
+        providers: [
+            provideAppInitializer(() => {
+                if (isPlatformServer(inject(PLATFORM_ID))) {
+                    const transignalService = inject(TransignalService);
+                    const { documentElement } = inject(DOCUMENT);
+                    const { availableLangs } = injectTransignalConfig();
+                    if (availableLangs.includes(documentElement.lang)) {
+                        transignalService.activeLang.set(documentElement.lang);
+                    }
+                }
+            }),
+        ],
+    };
+};
+
+class TransignalTitleStrategy extends TitleStrategy {
+    constructor(t) {
+        super();
+        this.t = t;
+        this.title = inject(Title);
+        this.injector = inject(EnvironmentInjector);
+    }
+    updateTitle(routerState) {
+        this.effectRef?.destroy();
+        const router = this.injector.get(Router);
+        const title = this.buildTitle(routerState) || 'default';
+        const translation = computed(() => this.t(title, router.getCurrentNavigation()?.extras.state), ...(ngDevMode ? [{ debugName: "translation" }] : []));
+        this.effectRef = runInInjectionContext(this.injector, () => effect(() => this.title.setTitle(translation()), { manualCleanup: true }));
+    }
+}
+/**
+ * Enables translation of title param in route definition with use of prepared {@link TitleStrategy}
+ * Automatically translates `title` param form route definition, sets website title and updates on language changes
+ * Also it is possible to use parameters from `navigation.extras.state`
+ *
+ * @example
+ * ```typescript
+ * // src/app/app.routes.ts
+ * export const routes = [
+ *   { path: 'base', title: 'base', children: [
+ *     { path: 'child', title: 'child' },
+ *   ],
+ *   { path: 'aux', outlet: 'popup', title: 'popupTitle' }
+ * ];
+ *
+ * // src/app/transignal.ts
+ * export const transignal = prepareTransignal(<config>, withTranslatedTitle('global'));
+ *
+ * // src/app/i18n/global/en.ts
+ * export default {
+ *   title: {
+ *     base: 'Base title',
+ *     child: 'Child title'
+ *     popupTitle: 'Popup title'
+ *   }
+ * };
+ * ```
+ *
+ * @param scope scope under which there are title translations
+ * @param translationKey translation key under which there are translations, `title` by default
+ */
+const withTranslatedTitle = (scope, translationKey = 'title') => {
+    return {
+        providers: [
+            makeEnvironmentProviders([
+                {
+                    provide: TitleStrategy,
+                    useFactory: (service = inject(TransignalService)) => new TransignalTitleStrategy(service.t(scope).prefix(translationKey)),
+                },
+            ]),
+        ],
+    };
+};
+
+// @ts-nocheck
+// This file is auto-generated during init process. Do not modify.
+// This disable this auto generate file.
+// set property "shouldGenerateAutogenIndexFile: false" 
+// in taon.jsonc of your project.
+
+var index = {};
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { APP_ID, BUILD_BASE_HREF, BUILD_FRAMEWORK_CLI_NAME, CURRENT_PACKAGE_TAON_VERSION, CURRENT_PACKAGE_VERSION, INTERNAL_TRANSIGNAL_CONFIG, PROJECT_NPM_NAME, TRANSIGNAL_CONFIG, TREE_SHAKED_TRANSLATIONS, TransignalService, injectTransignalConfig, noParamsHandler, plural, prepareTransignal, provideTransignalTesting, select, simpleParamValueStringify, simpleParamsHandler, startCli, treeShakedTranslations, withLanguageLocalStorageSync, withNavigatorLanguage, withPreloadScopes, withServerSideLanguage, withTranslatedTitle };
+//# sourceMappingURL=i18n-browser.mjs.map