@intlayer/ngx-translate 9.5.10

package/dist/esm/translateStore.mjs

@@ -0,0 +1,53 @@
+import { getValue, mergeDeep } from "./util.mjs";
+import * as i0 from "@angular/core";
+import { signal } from "@angular/core";
+import { Subject } from "rxjs";
+
+//#region src/translateStore.ts
+/**
+* Runtime translations registered through `setTranslation()` / a loader.
+* Intlayer dictionaries are resolved separately and never copied here.
+*/
+var TranslateStore = class TranslateStore {
+	translationsSignal = signal({});
+	translations = this.translationsSignal.asReadonly();
+	translationChangeSubject = new Subject();
+	translationChange$ = this.translationChangeSubject.asObservable();
+	getTranslations(language) {
+		return this.translations()[language] ?? {};
+	}
+	setTranslations(language, translations, shouldMerge) {
+		this.translationsSignal.update((current) => ({
+			...current,
+			[language]: shouldMerge && current[language] ? mergeDeep(current[language], translations) : translations
+		}));
+		this.translationChangeSubject.next({
+			lang: language,
+			translations: this.getTranslations(language)
+		});
+	}
+	deleteTranslations(language) {
+		this.translationsSignal.update(({ [language]: _removed, ...rest }) => rest);
+	}
+	getTranslationValue(language, key) {
+		return getValue(this.translations()[language], key);
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "17.0.0",
+		ngImport: i0,
+		type: TranslateStore,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Injectable
+	});
+	static ɵprov = i0.ɵɵngDeclareInjectable({
+		minVersion: "12.0.0",
+		version: "17.0.0",
+		ngImport: i0,
+		type: TranslateStore
+	});
+};
+
+//#endregion
+export { TranslateStore };
+//# sourceMappingURL=translateStore.mjs.map

package/dist/esm/translateStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"translateStore.mjs","names":[],"sources":["../../src/translateStore.ts"],"sourcesContent":["import * as i0 from '@angular/core';\nimport { signal } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport type {\n  FactoryDeclaration,\n  InjectableDeclaration,\n} from './partialDeclarations';\nimport type {\n  InterpolatableTranslationObject,\n  Language,\n  TranslationChangeEvent,\n} from './types';\nimport { getValue, mergeDeep } from './util';\n\n/**\n * Runtime translations registered through `setTranslation()` / a loader.\n * Intlayer dictionaries are resolved separately and never copied here.\n */\nexport class TranslateStore {\n  private readonly translationsSignal = signal<\n    Record<Language, InterpolatableTranslationObject>\n  >({});\n  readonly translations = this.translationsSignal.asReadonly();\n\n  private readonly translationChangeSubject =\n    new Subject<TranslationChangeEvent>();\n  readonly translationChange$ = this.translationChangeSubject.asObservable();\n\n  getTranslations(language: Language): InterpolatableTranslationObject {\n    return this.translations()[language] ?? {};\n  }\n\n  setTranslations(\n    language: Language,\n    translations: InterpolatableTranslationObject,\n    shouldMerge: boolean\n  ): void {\n    this.translationsSignal.update((current) => ({\n      ...current,\n      [language]:\n        shouldMerge && current[language]\n          ? mergeDeep(current[language], translations)\n          : translations,\n    }));\n    this.translationChangeSubject.next({\n      lang: language,\n      translations: this.getTranslations(language),\n    });\n  }\n\n  deleteTranslations(language: Language): void {\n    this.translationsSignal.update(({ [language]: _removed, ...rest }) => rest);\n  }\n\n  getTranslationValue(language: Language, key: string): unknown {\n    return getValue(this.translations()[language], key);\n  }\n\n  static ɵfac: i0.ɵɵFactoryDeclaration<TranslateStore, never> =\n    i0.ɵɵngDeclareFactory({\n      minVersion: '12.0.0',\n      version: '17.0.0',\n      ngImport: i0,\n      type: TranslateStore,\n      deps: [],\n      target: i0.ɵɵFactoryTarget.Injectable,\n    } as FactoryDeclaration) as never;\n  static ɵprov: i0.ɵɵInjectableDeclaration<TranslateStore> =\n    i0.ɵɵngDeclareInjectable({\n      minVersion: '12.0.0',\n      version: '17.0.0',\n      ngImport: i0,\n      type: TranslateStore,\n    } as InjectableDeclaration) as never;\n}\n"],"mappings":";;;;;;;;;;AAkBA,IAAa,iBAAb,MAAa,eAAe;CAC1B,AAAiB,qBAAqB,OAEpC,CAAC,CAAC;CACJ,AAAS,eAAe,KAAK,mBAAmB,WAAW;CAE3D,AAAiB,2BACf,IAAI,QAAgC;CACtC,AAAS,qBAAqB,KAAK,yBAAyB,aAAa;CAEzE,gBAAgB,UAAqD;EACnE,OAAO,KAAK,aAAa,CAAC,CAAC,aAAa,CAAC;CAC3C;CAEA,gBACE,UACA,cACA,aACM;EACN,KAAK,mBAAmB,QAAQ,aAAa;GAC3C,GAAG;IACF,WACC,eAAe,QAAQ,YACnB,UAAU,QAAQ,WAAW,YAAY,IACzC;EACR,EAAE;EACF,KAAK,yBAAyB,KAAK;GACjC,MAAM;GACN,cAAc,KAAK,gBAAgB,QAAQ;EAC7C,CAAC;CACH;CAEA,mBAAmB,UAA0B;EAC3C,KAAK,mBAAmB,QAAQ,GAAG,WAAW,UAAU,GAAG,WAAW,IAAI;CAC5E;CAEA,oBAAoB,UAAoB,KAAsB;EAC5D,OAAO,SAAS,KAAK,aAAa,CAAC,CAAC,WAAW,GAAG;CACpD;CAEA,OAAO,OACL,GAAG,mBAAmB;EACpB,YAAY;EACZ,SAAS;EACT,UAAU;EACV,MAAM;EACN,MAAM,CAAC;EACP,QAAQ,GAAG,gBAAgB;CAC7B,CAAuB;CACzB,OAAO,QACL,GAAG,sBAAsB;EACvB,YAAY;EACZ,SAAS;EACT,UAAU;EACV,MAAM;CACR,CAA0B;AAC9B"}

package/dist/esm/util.mjs

@@ -0,0 +1,44 @@
+import { navigatePath } from "@intlayer/core/messageFormat";
+
+//#region src/util.ts
+const isDefined = (value) => typeof value !== "undefined";
+const isDefinedAndNotNull = (value) => typeof value !== "undefined" && value !== null;
+const isObject = (value) => typeof value === "object" && value !== null;
+const isDict = (value) => isObject(value) && !Array.isArray(value);
+const isArray = (value) => Array.isArray(value);
+const isString = (value) => typeof value === "string";
+const isFunction = (value) => typeof value === "function";
+/** Deep structural equality over plain objects and arrays. */
+const equals = (first, second) => {
+	if (first === second) return true;
+	if (!isObject(first) || !isObject(second)) return false;
+	if (Array.isArray(first) !== Array.isArray(second)) return false;
+	const firstKeys = Object.keys(first);
+	if (firstKeys.length !== Object.keys(second).length) return false;
+	return firstKeys.every((key) => Object.hasOwn(second, key) && equals(first[key], second[key]));
+};
+/** Merges `source` into `target` recursively, returning a new object. */
+const mergeDeep = (target, source) => {
+	if (!isDict(target) || !isDict(source)) return source;
+	const output = { ...target };
+	for (const [key, value] of Object.entries(source)) output[key] = isDict(value) && isDict(output[key]) ? mergeDeep(output[key], value) : value;
+	return output;
+};
+/**
+* Reads a dotted key, trying the flat key first (`{ 'a.b': … }`) like
+* ngx-translate.
+*/
+const getValue = (target, key) => key ? navigatePath(target, key) : void 0;
+/** Returns a copy of `target` with `value` written at the dotted `key`. */
+const insertValue = (target, key, value) => {
+	const [head, ...rest] = key.split(".");
+	const source = isDict(target) ? target : {};
+	return {
+		...source,
+		[head]: rest.length ? insertValue(source[head] ?? {}, rest.join("."), value) : value
+	};
+};
+
+//#endregion
+export { equals, getValue, insertValue, isArray, isDefined, isDefinedAndNotNull, isDict, isFunction, isObject, isString, mergeDeep };
+//# sourceMappingURL=util.mjs.map

package/dist/esm/util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.mjs","names":[],"sources":["../../src/util.ts"],"sourcesContent":["import { navigatePath } from '@intlayer/core/messageFormat';\n\ntype PlainObject = Record<string, unknown>;\n\nexport const isDefined = <T>(value: T | null | undefined): value is T | null =>\n  typeof value !== 'undefined';\n\nexport const isDefinedAndNotNull = <T>(\n  value: T | null | undefined\n): value is T => typeof value !== 'undefined' && value !== null;\n\nexport const isObject = (value: unknown): value is PlainObject =>\n  typeof value === 'object' && value !== null;\n\nexport const isDict = (value: unknown): value is PlainObject =>\n  isObject(value) && !Array.isArray(value);\n\nexport const isArray = (value: unknown): value is unknown[] =>\n  Array.isArray(value);\n\nexport const isString = (value: unknown): value is string =>\n  typeof value === 'string';\n\nexport const isFunction = (\n  value: unknown\n): value is (...args: unknown[]) => unknown => typeof value === 'function';\n\n/** Deep structural equality over plain objects and arrays. */\nexport const equals = (first: unknown, second: unknown): boolean => {\n  if (first === second) return true;\n  if (!isObject(first) || !isObject(second)) return false;\n  if (Array.isArray(first) !== Array.isArray(second)) return false;\n\n  const firstKeys = Object.keys(first);\n  if (firstKeys.length !== Object.keys(second).length) return false;\n\n  return firstKeys.every(\n    (key) => Object.hasOwn(second, key) && equals(first[key], second[key])\n  );\n};\n\n/** Merges `source` into `target` recursively, returning a new object. */\nexport const mergeDeep = <T>(target: T, source: unknown): T => {\n  if (!isDict(target) || !isDict(source)) return source as T;\n\n  const output: PlainObject = { ...target };\n\n  for (const [key, value] of Object.entries(source)) {\n    output[key] =\n      isDict(value) && isDict(output[key])\n        ? mergeDeep(output[key], value)\n        : value;\n  }\n\n  return output as T;\n};\n\n/**\n * Reads a dotted key, trying the flat key first (`{ 'a.b': … }`) like\n * ngx-translate.\n */\nexport const getValue = (target: unknown, key: string): unknown =>\n  key ? navigatePath(target, key) : undefined;\n\n/** Returns a copy of `target` with `value` written at the dotted `key`. */\nexport const insertValue = <T>(\n  target: Readonly<T>,\n  key: string,\n  value: unknown\n): T => {\n  const [head, ...rest] = key.split('.');\n  const source: PlainObject = isDict(target) ? target : {};\n\n  return {\n    ...source,\n    [head as string]: rest.length\n      ? insertValue(source[head as string] ?? {}, rest.join('.'), value)\n      : value,\n  } as T;\n};\n"],"mappings":";;;AAIA,MAAa,aAAgB,UAC3B,OAAO,UAAU;AAEnB,MAAa,uBACX,UACe,OAAO,UAAU,eAAe,UAAU;AAE3D,MAAa,YAAY,UACvB,OAAO,UAAU,YAAY,UAAU;AAEzC,MAAa,UAAU,UACrB,SAAS,KAAK,KAAK,CAAC,MAAM,QAAQ,KAAK;AAEzC,MAAa,WAAW,UACtB,MAAM,QAAQ,KAAK;AAErB,MAAa,YAAY,UACvB,OAAO,UAAU;AAEnB,MAAa,cACX,UAC6C,OAAO,UAAU;;AAGhE,MAAa,UAAU,OAAgB,WAA6B;CAClE,IAAI,UAAU,QAAQ,OAAO;CAC7B,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,MAAM,GAAG,OAAO;CAClD,IAAI,MAAM,QAAQ,KAAK,MAAM,MAAM,QAAQ,MAAM,GAAG,OAAO;CAE3D,MAAM,YAAY,OAAO,KAAK,KAAK;CACnC,IAAI,UAAU,WAAW,OAAO,KAAK,MAAM,CAAC,CAAC,QAAQ,OAAO;CAE5D,OAAO,UAAU,OACd,QAAQ,OAAO,OAAO,QAAQ,GAAG,KAAK,OAAO,MAAM,MAAM,OAAO,IAAI,CACvE;AACF;;AAGA,MAAa,aAAgB,QAAW,WAAuB;CAC7D,IAAI,CAAC,OAAO,MAAM,KAAK,CAAC,OAAO,MAAM,GAAG,OAAO;CAE/C,MAAM,SAAsB,EAAE,GAAG,OAAO;CAExC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,GAC9C,OAAO,OACL,OAAO,KAAK,KAAK,OAAO,OAAO,IAAI,IAC/B,UAAU,OAAO,MAAM,KAAK,IAC5B;CAGR,OAAO;AACT;;;;;AAMA,MAAa,YAAY,QAAiB,QACxC,MAAM,aAAa,QAAQ,GAAG,IAAI;;AAGpC,MAAa,eACX,QACA,KACA,UACM;CACN,MAAM,CAAC,MAAM,GAAG,QAAQ,IAAI,MAAM,GAAG;CACrC,MAAM,SAAsB,OAAO,MAAM,IAAI,SAAS,CAAC;CAEvD,OAAO;EACL,GAAG;GACF,OAAiB,KAAK,SACnB,YAAY,OAAO,SAAmB,CAAC,GAAG,KAAK,KAAK,GAAG,GAAG,KAAK,IAC/D;CACN;AACF"}

package/dist/types/esbuild/index.d.ts

@@ -0,0 +1,23 @@
+import { EsbuildPlugin, IntlayerEsbuildPluginOptions } from "angular-intlayer/esbuild";
+//#region src/esbuild/index.d.ts
+/**
+ * esbuild plugin for the Angular CLI (`@angular-builders/custom-esbuild`):
+ * sets up angular-intlayer's build integration and resolves
+ * `@ngx-translate/core` to `@intlayer/ngx-translate`.
+ *
+ * The redirect goes through `build.resolve`, so the adapter takes the same
+ * path as any intlayer package — including angular-intlayer's handling of
+ * the dev server, which would otherwise externalize it to Vite's
+ * pre-bundler.
+ *
+ * @example
+ * ```ts
+ * // esbuild/plugins.ts (referenced from angular.json "plugins")
+ * import { ngxTranslateEsbuildPlugin } from '@intlayer/ngx-translate/esbuild';
+ * export default [ngxTranslateEsbuildPlugin()];
+ * ```
+ */
+export declare const ngxTranslateEsbuildPlugin: (options?: IntlayerEsbuildPluginOptions) => EsbuildPlugin;
+//#endregion
+export { ngxTranslateEsbuildPlugin as default };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/esbuild/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/esbuild/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBA6Ba,4BAAyB,UAC1B,iCACT"}

package/dist/types/handlers.d.ts

@@ -0,0 +1,52 @@
+import { InterpolatableTranslation, InterpolatableTranslationObject, InterpolationParameters, MissingTranslationHandlerParams, StrictTranslation, TranslationObject } from "./types.js";
+import * as i0 from "@angular/core";
+import { Observable } from "rxjs";
+//#region src/handlers.d.ts
+/** Handles a key missing from every translation source. */
+export declare abstract class MissingTranslationHandler {
+  abstract handle(params: MissingTranslationHandlerParams): StrictTranslation | Observable<StrictTranslation> | undefined;
+}
+/** Returns the key itself, ngx-translate's default. */
+export declare class DefaultMissingTranslationHandler implements MissingTranslationHandler {
+  handle(params: MissingTranslationHandlerParams): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DefaultMissingTranslationHandler, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<DefaultMissingTranslationHandler>;
+}
+/** Compiles runtime translations registered through `setTranslation()`. */
+export declare abstract class TranslateCompiler {
+  abstract compile(value: string, lang: string): InterpolatableTranslation;
+  abstract compileTranslations(translations: TranslationObject, lang: string): InterpolatableTranslationObject;
+}
+export declare class TranslateNoOpCompiler extends TranslateCompiler {
+  compile(value: string, _lang: string): string;
+  compileTranslations(translations: TranslationObject, _lang: string): InterpolatableTranslationObject;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TranslateNoOpCompiler, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<TranslateNoOpCompiler>;
+}
+/**
+ * Loads runtime translations for a language. Intlayer dictionaries need no
+ * loader; one is only called for catalogs kept outside intlayer.
+ */
+export declare abstract class TranslateLoader {
+  abstract getTranslation(lang: string): Observable<TranslationObject>;
+}
+export declare class TranslateNoOpLoader extends TranslateLoader {
+  getTranslation(_lang: string): Observable<TranslationObject>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TranslateNoOpLoader, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<TranslateNoOpLoader>;
+}
+/** Interpolates parameters into a translation. */
+export declare abstract class TranslateParser {
+  abstract interpolate(expression: InterpolatableTranslation, params?: InterpolationParameters): string | undefined;
+}
+/** `{{ name }}` / `{{ user.name }}` interpolation, like ngx-translate. */
+export declare class TranslateDefaultParser extends TranslateParser {
+  templateMatcher: RegExp;
+  interpolate(expression: InterpolatableTranslation, params?: InterpolationParameters): string | undefined;
+  protected interpolateString(expression: string, params?: InterpolationParameters): string;
+  protected formatValue(value: unknown): string | undefined;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TranslateDefaultParser, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<TranslateDefaultParser>;
+}
+//#endregion
+//# sourceMappingURL=handlers.d.ts.map

package/dist/types/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","names":[],"sources":["../../src/handlers.ts"],"mappings":";;;;;8BAwBsB;WACX,OACP,QAAQ,kCACP,oBAAoB,WAAW;;;qBAIvB,4CACA;EAEX,OAAO,QAAQ;SAIR,MAAM,GAAG,qBACd;SAUK,OAAO,GAAG,wBAAwB;;;8BAUrB;WACX,QAAQ,eAAe,eAAe;WACtC,oBACP,cAAc,mBACd,eACC;;qBAGQ,8BAA8B;EACzC,QAAQ,eAAe;EAIvB,oBACE,cAAc,mBACd,gBACC;SAII,MAAM,GAAG,qBAAqB;SAS9B,OAAO,GAAG,wBAAwB;;;;;;8BAarB;WACX,eAAe,eAAe,WAAW;;qBAGvC,4BAA4B;EACvC,eAAe,gBAAgB,WAAW;SAInC,MAAM,GAAG,qBAAqB;SAS9B,OAAO,GAAG,wBAAwB;;;8BAUrB;WACX,YACP,YAAY,2BACZ,SAAS;;;qBAKA,+BAA+B;EAC1C,iBAAe;EAEf,YACE,YAAY,2BACZ,SAAS;YAWD,kBACR,oBACA,SAAS;YAaD,YAAY;SAWf,MAAM,GAAG,qBAAqB;SAS9B,OAAO,GAAG,wBAAwB"}

package/dist/types/index.d.ts

@@ -0,0 +1,11 @@
+import { ChildTranslateServiceConfig, DeepReadonly, DefaultLangChangeEvent, FallbackLangChangeEvent, InterpolatableTranslation, InterpolatableTranslationObject, InterpolateFunction, InterpolationParameters, LangChangeEvent, Language, MissingTranslationHandlerParams, RootTranslateServiceConfig, StrictTranslation, TranslateProvider, TranslateProviders, TranslateServiceConfig, Translation, TranslationChangeEvent, TranslationObject } from "./types.js";
+import { DefaultMissingTranslationHandler, MissingTranslationHandler, TranslateCompiler, TranslateDefaultParser, TranslateLoader, TranslateNoOpCompiler, TranslateNoOpLoader, TranslateParser } from "./handlers.js";
+import { provideChildTranslateService, provideMissingTranslationHandler, provideTranslateCompiler, provideTranslateLoader, provideTranslateParser, provideTranslateService } from "./providers.js";
+import { _, translate } from "./standalone.js";
+import { TranslateBlockContext, TranslateBlockDirective } from "./translateBlockDirective.js";
+import { TranslateDirective } from "./translateDirective.js";
+import { TranslatePipe } from "./translatePipe.js";
+import { TranslateStore } from "./translateStore.js";
+import { ITranslateService, TRANSLATE_SERVICE_CONFIG, TranslateService } from "./translateService.js";
+import { equals, getValue, insertValue, isArray, isDefined, isDefinedAndNotNull, isDict, isFunction, isObject, isString, mergeDeep } from "./util.js";
+export { type ChildTranslateServiceConfig, type DeepReadonly, type DefaultLangChangeEvent, DefaultMissingTranslationHandler, type FallbackLangChangeEvent, ITranslateService, type InterpolatableTranslation, type InterpolatableTranslationObject, type InterpolateFunction, type InterpolationParameters, type LangChangeEvent, type Language, MissingTranslationHandler, type MissingTranslationHandlerParams, type RootTranslateServiceConfig, type StrictTranslation, TRANSLATE_SERVICE_CONFIG, TranslateBlockContext, TranslateBlockDirective, TranslateCompiler, TranslateDefaultParser, TranslateDirective, TranslateLoader, TranslateNoOpCompiler, TranslateNoOpLoader, TranslateParser, TranslatePipe, type TranslateProvider, type TranslateProviders, TranslateService, type TranslateServiceConfig, TranslateStore, type Translation, type TranslationChangeEvent, type TranslationObject, _, equals, getValue, insertValue, isArray, isDefined, isDefinedAndNotNull, isDict, isFunction, isObject, isString, mergeDeep, provideChildTranslateService, provideMissingTranslationHandler, provideTranslateCompiler, provideTranslateLoader, provideTranslateParser, provideTranslateService, translate };

package/dist/types/partialDeclarations.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+//#region src/partialDeclarations.d.ts
+/**
+ * Argument types of Angular's partial-declaration functions.
+ *
+ * The public facade types omit `minVersion`, a field only the linker reads,
+ * so each declaration literal is cast to its facade widened with it. The cast
+ * vanishes at compile time: the linker still sees a plain object literal.
+ */
+type WithMinVersion<T> = T & {
+  minVersion: string;
+};
+export type FactoryDeclaration = WithMinVersion<Parameters<typeof i0.ɵɵngDeclareFactory>[0]>;
+export type InjectableDeclaration = WithMinVersion<Parameters<typeof i0.ɵɵngDeclareInjectable>[0]>;
+export type PipeDeclaration = WithMinVersion<Parameters<typeof i0.ɵɵngDeclarePipe>[0]>;
+export type DirectiveDeclaration = WithMinVersion<Parameters<typeof i0.ɵɵngDeclareDirective>[0]>;
+//#endregion
+//# sourceMappingURL=partialDeclarations.d.ts.map

package/dist/types/partialDeclarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partialDeclarations.d.ts","names":[],"sources":["../../src/partialDeclarations.ts"],"mappings":";;;;;;;;;KASK,eAAe,KAAK;EAAM;;YAEnB,qBAAqB,eAC/B,kBAAkB,GAAG;YAEX,wBAAwB,eAClC,kBAAkB,GAAG;YAEX,kBAAkB,eAC5B,kBAAkB,GAAG;YAEX,uBAAuB,eACjC,kBAAkB,GAAG"}

package/dist/types/plugin/index.d.ts

@@ -0,0 +1,25 @@
+import { CallerDescriptor } from "@intlayer/config/callers";
+import { PluginOption } from "vite";
+import { intlayer } from "vite-intlayer";
+//#region src/plugin/index.d.ts
+/**
+ * ngx-translate callers as the field-usage analysis must see them.
+ *
+ * The `| translate` pipe and `[translate]` directive read keys from Angular
+ * templates that no JS analyser parses, so a `translate('home.title')` call
+ * in a component class cannot prove which other fields of `home` its
+ * template needs. Every dictionary reached from ngx-translate is therefore
+ * kept whole (`'all'`); dictionaries only read through `useIntlayer` still
+ * get pruned.
+ */
+export declare const NGX_TRANSLATE_BUILD_CALLERS: CallerDescriptor[];
+/**
+ * Vite plugin for Angular apps built with Vite (Analog): wraps vite-intlayer
+ * and aliases `@ngx-translate/core` to `@intlayer/ngx-translate`.
+ *
+ * Angular CLI apps use `@intlayer/ngx-translate/esbuild` instead.
+ */
+export declare const ngxTranslateVitePlugin: (options?: Parameters<typeof intlayer>[0]) => PluginOption[];
+//#endregion
+export { ngxTranslateVitePlugin as default };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;;;;;;;;;qBAsBa,6BAA6B;;;;;;;qBAY7B,yBAAsB,UACvB,kBAAkB,iBAC3B"}

package/dist/types/providers.d.ts

@@ -0,0 +1,22 @@
+import { ChildTranslateServiceConfig, RootTranslateServiceConfig } from "./types.js";
+import { MissingTranslationHandler, TranslateCompiler, TranslateLoader, TranslateParser } from "./handlers.js";
+import { Provider, Type } from "@angular/core";
+//#region src/providers.d.ts
+/** A class to instantiate, or a factory returning the instance. */
+type ClassOrFactory<T> = Type<T> | (() => T);
+export declare const provideTranslateLoader: (loader: ClassOrFactory<TranslateLoader>) => Provider;
+export declare const provideTranslateCompiler: (compiler: ClassOrFactory<TranslateCompiler>) => Provider;
+export declare const provideTranslateParser: (parser: ClassOrFactory<TranslateParser>) => Provider;
+export declare const provideMissingTranslationHandler: (handler: ClassOrFactory<MissingTranslationHandler>) => Provider;
+/**
+ * Root providers: `bootstrapApplication(App, { providers: [
+ * provideIntlayer(), provideTranslateService({ fallbackLang: 'en' })] })`.
+ */
+export declare const provideTranslateService: (config?: RootTranslateServiceConfig) => Provider[];
+/**
+ * Providers for a lazy route or component subtree. Every service shares
+ * intlayer's locale, so a child service only scopes runtime translations.
+ */
+export declare const provideChildTranslateService: (config?: ChildTranslateServiceConfig) => Provider[];
+//#endregion
+//# sourceMappingURL=providers.d.ts.map

package/dist/types/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","names":[],"sources":["../../src/providers.ts"],"mappings":";;;;;KAoBK,eAAe,KAAK,KAAK,YAAY;qBAe7B,yBAAsB,QACzB,eAAe,qBACtB;qBAEU,2BAAwB,UACzB,eAAe,uBACxB;qBAEU,yBAAsB,QACzB,eAAe,qBACtB;qBAEU,mCAAgC,SAClC,eAAe,+BACvB;;;;;qBA0CU,0BAAuB,SAC1B,+BACP;;;;;qBAMU,+BAA4B,SAC/B,gCACP"}

package/dist/types/registryLookup.d.ts

@@ -0,0 +1,13 @@
+//#region src/registryLookup.d.ts
+/**
+ * Looks up an ngx-translate key across the intlayer dictionaries:
+ *
+ * 1. `'home.title'` → dictionary `home`, field `title`;
+ * 2. `'home'` → the whole `home` dictionary;
+ * 3. the full key in every dictionary — a single migrated `en.json`.
+ *
+ * @returns The interpreted node (string, object or callable), or `undefined`.
+ */
+export declare const lookupRegistryTranslation: (key: string, locale: string) => unknown;
+//#endregion
+//# sourceMappingURL=registryLookup.d.ts.map

package/dist/types/registryLookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registryLookup.d.ts","names":[],"sources":["../../src/registryLookup.ts"],"mappings":";;;;;;;;;;qBAuCa,4BAAyB,aACzB"}

package/dist/types/standalone.d.ts

@@ -0,0 +1,24 @@
+import { InterpolationParameters, Language, Translation } from "./types.js";
+import { Signal } from "@angular/core";
+//#region src/standalone.d.ts
+/**
+ * Signal of a translation, updated on language change. Must run in an
+ * injection context.
+ *
+ * @example
+ * ```ts
+ * readonly title = translate('home.title');
+ * ```
+ */
+export declare const translate: (key: string | string[] | (() => string | string[]), params?: InterpolationParameters | (() => InterpolationParameters | undefined), lang?: Language | (() => Language | undefined)) => Signal<Translation>;
+/**
+ * Marks a key for extraction tools; returns it unchanged.
+ *
+ * @example
+ * ```ts
+ * const titleKey = _('home.title');
+ * ```
+ */
+export declare const _: <T extends string | string[]>(key: T) => T;
+//#endregion
+//# sourceMappingURL=standalone.d.ts.map

package/dist/types/standalone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone.d.ts","names":[],"sources":["../../src/standalone.ts"],"mappings":";;;;;;;;;;;;qBAaa,YAAS,oDAC8B,SAE9C,iCACO,sCAAoC,OACxC,kBAAkB,0BACxB,OAAO;;;;;;;;;qBAUG,IAAK,6BAA2B,KAAO,MAAI"}

package/dist/types/translateBlockDirective.d.ts

@@ -0,0 +1,23 @@
+import { InterpolationParameters, Translation } from "./types.js";
+import * as i0 from "@angular/core";
+//#region src/translateBlockDirective.d.ts
+/** Template context of `*translateBlock="let t"`. */
+export declare class TranslateBlockContext {
+  $implicit: (key: string, params?: InterpolationParameters) => Translation;
+  constructor($implicit: (key: string, params?: InterpolationParameters) => Translation);
+}
+/**
+ * `<div *translateBlock="let t">{{ t('home.title') }}</div>` — exposes
+ * `instant` to a template block.
+ */
+export declare class TranslateBlockDirective {
+  private readonly templateRef;
+  private readonly viewContainer;
+  private readonly translateService;
+  ngOnInit(): void;
+  static ngTemplateContextGuard(_directive: TranslateBlockDirective, _context: unknown): _context is TranslateBlockContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TranslateBlockDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<TranslateBlockDirective, '[translateBlock]', never, {}, {}, never, never, true, never>;
+}
+//#endregion
+//# sourceMappingURL=translateBlockDirective.d.ts.map

package/dist/types/translateBlockDirective.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translateBlockDirective.d.ts","names":[],"sources":["../../src/translateBlockDirective.ts"],"mappings":";;;;qBAUa;EAEF,YACL,aACA,SAAS,4BACN;EAJP,YACS,YACL,aACA,SAAS,4BACN;;;;;;qBAQI;mBACM;mBAEA;mBACA;EAEjB;SASO,uBACL,YAAY,yBACZ,oBACC,YAAY;SAIR,MAAM,GAAG,qBAAqB;SAS9B,MAAM,GAAG,uBACd"}

package/dist/types/translateDirective.d.ts

@@ -0,0 +1,33 @@
+import { InterpolationParameters } from "./types.js";
+import * as i0 from "@angular/core";
+//#region src/translateDirective.d.ts
+/**
+ * `<p [translate]="'home.title'" [translateParams]="{ name }"></p>` or
+ * `<p translate>home.title</p>` — writes the translation as text content.
+ */
+export declare class TranslateDirective {
+  private readonly translateService;
+  private readonly element;
+  private readonly injector;
+  private readonly keySignal;
+  private readonly paramsSignal;
+  private translation;
+  set translate(key: string);
+  set translateParams(params: InterpolationParameters);
+  /** Content-key form: the element's own text is the key. */
+  ngAfterViewInit(): void;
+  private ensureRendering;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TranslateDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<TranslateDirective, '[translate],[ngx-translate]', never, {
+    translate: {
+      alias: 'translate';
+      required: false;
+    };
+    translateParams: {
+      alias: 'translateParams';
+      required: false;
+    };
+  }, {}, never, never, true, never>;
+}
+//#endregion
+//# sourceMappingURL=translateDirective.d.ts.map

package/dist/types/translateDirective.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translateDirective.d.ts","names":[],"sources":["../../src/translateDirective.ts"],"mappings":";;;;;;;qBAsBa;mBACM;mBACA;mBACA;mBAEA;mBAEA;UAGT;MAEJ,UAAU;MAMV,gBAAgB,QAAQ;;EAK5B;UAUQ;SAqBD,MAAM,GAAG,qBAAqB;SAS9B,MAAM,GAAG,uBACd;IAIE;MAAa;MAAoB;;IACjC;MAAmB;MAA0B"}

package/dist/types/translatePipe.d.ts

@@ -0,0 +1,21 @@
+import { Translation } from "./types.js";
+import * as i0 from "@angular/core";
+import { PipeTransform } from "@angular/core";
+//#region src/translatePipe.d.ts
+/**
+ * `{{ 'home.title' | translate: { name } }}` — impure pipe reading a
+ * translation signal, so the view refreshes on language change.
+ */
+export declare class TranslatePipe implements PipeTransform {
+  private readonly translateService;
+  private cachedTranslation;
+  private lastKey;
+  private lastParams;
+  transform(query: string | undefined | null, ...args: unknown[]): Translation | undefined | null;
+  /** Accepts an object, or an object literal written as a template string. */
+  private parseArgs;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TranslatePipe, never>;
+  static ɵpipe: i0.ɵɵPipeDeclaration<TranslatePipe, 'translate', true>;
+}
+//#endregion
+//# sourceMappingURL=translatePipe.d.ts.map

package/dist/types/translatePipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translatePipe.d.ts","names":[],"sources":["../../src/translatePipe.ts"],"mappings":";;;;;;;;qBAca,yBAAyB;mBACnB;UACT;UACA;UACA;EAER,UACE,qCACG,kBACF;;UAkBK;SAmBD,MAAM,GAAG,qBAAqB;SAS9B,OAAO,GAAG,kBAAkB"}

package/dist/types/translateService.d.ts

@@ -0,0 +1,106 @@
+import { FallbackLangChangeEvent, InterpolatableTranslationObject, InterpolationParameters, LangChangeEvent, Language, RootTranslateServiceConfig, StrictTranslation, Translation, TranslationChangeEvent, TranslationObject } from "./types.js";
+import { MissingTranslationHandler, TranslateCompiler, TranslateLoader, TranslateParser } from "./handlers.js";
+import { TranslateStore } from "./translateStore.js";
+import * as i0 from "@angular/core";
+import { InjectionToken, Signal } from "@angular/core";
+import { Observable } from "rxjs";
+//#region src/translateService.d.ts
+/** Resolved `provideTranslateService()` options. */
+export declare const TRANSLATE_SERVICE_CONFIG: InjectionToken<RootTranslateServiceConfig>;
+/** A key, a key list, or a reactive source of either. */
+type KeyInput = string | string[] | (() => string | string[]);
+/** Abstract API of {@link TranslateService}, kept for type compatibility. */
+export declare abstract class ITranslateService {}
+/**
+ * ngx-translate's `TranslateService` over intlayer.
+ *
+ * - The active language is angular-intlayer's locale signal, so `use()`,
+ *   `useLocale().setLocale()` and `useIntlayer()` share one locale.
+ * - Keys resolve against runtime translations (`setTranslation()`, a
+ *   configured loader) first, then the intlayer dictionaries — the first key
+ *   segment names the dictionary (`'home.title'` → `home`).
+ * - Everything is synchronous: dictionaries are bundled, so `get()` and
+ *   `use()` emit immediately.
+ */
+export declare class TranslateService extends ITranslateService {
+  private readonly intlayerClient;
+  private readonly config;
+  readonly store: TranslateStore;
+  readonly currentLoader: TranslateLoader;
+  readonly compiler: TranslateCompiler;
+  readonly parser: TranslateParser;
+  readonly missingTranslationHandler: MissingTranslationHandler;
+  private readonly fallbackLangSignal;
+  private readonly isLoadingSignal;
+  private readonly langChangeSubject;
+  private readonly fallbackLangChangeSubject;
+  /** The active language, shared with angular-intlayer. */
+  readonly currentLang: Signal<Language>;
+  readonly fallbackLang: Signal<Language | null>;
+  readonly isLoading: Signal<boolean>;
+  readonly onLangChange: Observable<LangChangeEvent>;
+  readonly onFallbackLangChange: Observable<FallbackLangChangeEvent>;
+  /** @deprecated Use `onFallbackLangChange`. */
+  readonly onDefaultLangChange: Observable<FallbackLangChangeEvent>;
+  readonly onTranslationChange: Observable<TranslationChangeEvent>;
+  /** Emits whenever displayed translations may have changed. */
+  readonly onTranslationRefresh: Observable<unknown>;
+  constructor();
+  getCurrentLang(): Language;
+  getFallbackLang(): Language | null;
+  /** Sets the language whose translations fill the gaps of the active one. */
+  setFallbackLang(lang: Language): Observable<InterpolatableTranslationObject>;
+  /** @deprecated Use `setFallbackLang`. */
+  setDefaultLang(lang: Language): Observable<InterpolatableTranslationObject>;
+  /** @deprecated Use `getFallbackLang`. */
+  getDefaultLang(): Language | null;
+  /** Activates a language, through angular-intlayer's locale. */
+  use(lang: Language): Observable<InterpolatableTranslationObject>;
+  /**
+   * Runs a configured loader once per language. Intlayer dictionaries need
+   * none, so the default no-op loader short-circuits.
+   */
+  private loadTranslations;
+  reloadLang(lang: Language): Observable<InterpolatableTranslationObject>;
+  resetLang(lang: Language): void;
+  /** Languages declared in intlayer plus any registered at runtime. */
+  getLangs(): readonly Language[];
+  /** Kept for API parity: the intlayer configuration owns the locale list. */
+  addLangs(_languages: Language[]): void;
+  getTranslations(lang: Language): InterpolatableTranslationObject;
+  getTranslation(lang: Language): Observable<InterpolatableTranslationObject>;
+  /** Registers runtime translations, compiled by the configured compiler. */
+  setTranslation(lang: Language, translations: TranslationObject, shouldMerge?: boolean): void;
+  /** Registers translations that are already compiled. */
+  setCompiledTranslation(lang: Language, translations: InterpolatableTranslationObject, shouldMerge?: boolean): void;
+  /** Sets one runtime translation. */
+  set(key: string, translation: string | TranslationObject, lang?: Language): void;
+  /**
+   * Interpolates a raw translation, recursing into subtrees. Strings go
+   * through the configured parser (`{{ name }}`); functions are either
+   * compiled runtime translations (parser) or intlayer nodes (resolver).
+   */
+  private interpolate;
+  /** Interpolated translation of `key` in `lang`, or `undefined`. */
+  private resolveKey;
+  /** Translation of a key, or of each key of a list. */
+  getParsedResult(key: string | string[], interpolateParams?: InterpolationParameters, lang?: Language): StrictTranslation | Observable<StrictTranslation>;
+  /** Synchronous translation. Reads signals, so it is reactive in templates. */
+  instant(key: string | string[], interpolateParams?: InterpolationParameters, lang?: Language): Translation;
+  /** Emits the translation once. */
+  get(key: string | string[], interpolateParams?: InterpolationParameters, lang?: Language): Observable<Translation>;
+  /** Emits the translation now and after every language change. */
+  stream(key: string | string[], interpolateParams?: InterpolationParameters, lang?: Language): Observable<Translation>;
+  /** Signal of the translation, updated on language or translation change. */
+  translate(key: KeyInput, params?: InterpolationParameters | (() => InterpolationParameters | undefined), lang?: Language | (() => Language | undefined)): Signal<Translation>;
+  getBrowserLang(): Language | undefined;
+  getBrowserCultureLang(): Language | undefined;
+  /** The browser's language without region, e.g. `"de"`. */
+  static getBrowserLang(): Language | undefined;
+  /** The browser's language with region, e.g. `"de-DE"`. */
+  static getBrowserCultureLang(): Language | undefined;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TranslateService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<TranslateService>;
+}
+//#endregion
+//# sourceMappingURL=translateService.d.ts.map

package/dist/types/translateService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translateService.d.ts","names":[],"sources":["../../src/translateService.ts"],"mappings":";;;;;;;;qBAmDa,0BAAwB,eAAA;;KAIhC;;8BAOiB;;;;;;;;;;;;qBAaT,yBAAyB;mBACnB;mBACA;WAIR,OAAK;WACL,eAAa;WACb,UAAQ;WACR,QAAM;WACN,2BAAyB;mBAEjB;mBACA;mBACA;mBACA;;WAIR,aAAa,OAAO;WAGpB,cAAc,OAAO;WAErB,WAAW;WAEX,cAAc,WAAW;WAEzB,sBAAsB,WAAW;;WAGjC,qBAAmB,WAAA;WACnB,qBAAqB,WAAW;;WAGhC,sBAAsB;EAM/B;EASA,kBAAkB;EAIlB,mBAAmB;;EAKnB,gBAAgB,MAAM,WAAW,WAAW;;EAU5C,eAAe,MAAM,WAAW,WAAW;;EAK3C,kBAAkB;;EAKlB,IAAI,MAAM,WAAW,WAAW;;;;;UAkBxB;EAqBR,WAAW,MAAM,WAAW,WAAW;EAKvC,UAAU,MAAM;;EAKhB,qBAAqB;;EAUrB,SAAS,YAAY;EAErB,gBAAgB,MAAM,WAAW;EAIjC,eAAe,MAAM,WAAW,WAAW;;EAK3C,eACE,MAAM,UACN,cAAc,mBACd;;EAUF,uBACE,MAAM,UACN,cAAc,iCACd;;EAMF,IACE,aACA,sBAAsB,mBACtB,OAAM;;;;;;UAoBA;;UA8BA;;EA6BR,gBACE,wBACA,oBAAoB,yBACpB,OAAO,WACN,oBAAoB,WAAW;;EAkClC,QACE,wBACA,oBAAoB,yBACpB,OAAO,WACN;;EAWH,IACE,wBACA,oBAAoB,yBACpB,OAAO,WACN,WAAW;;EAKd,OACE,wBACA,oBAAoB,yBACpB,OAAO,WACN,WAAW;;EAQd,UACE,KAAK,UACL,SACI,iCACO,sCACX,OAAO,kBAAkB,wBACxB,OAAO;EAMV,kBAAkB;EAIlB,yBAAyB;;SAKlB,kBAAkB;;SAKlB,yBAAyB;SAKzB,MAAM,GAAG,qBAAqB;SAS9B,OAAO,GAAG,wBAAwB"}

package/dist/types/translateStore.d.ts

@@ -0,0 +1,21 @@
+import { InterpolatableTranslationObject, LangChangeEvent, Language } from "./types.js";
+import * as i0 from "@angular/core";
+//#region src/translateStore.d.ts
+/**
+ * Runtime translations registered through `setTranslation()` / a loader.
+ * Intlayer dictionaries are resolved separately and never copied here.
+ */
+export declare class TranslateStore {
+  private readonly translationsSignal;
+  readonly translations: i0.Signal<Record<string, InterpolatableTranslationObject>>;
+  private readonly translationChangeSubject;
+  readonly translationChange$: import("rxjs").Observable<LangChangeEvent>;
+  getTranslations(language: Language): InterpolatableTranslationObject;
+  setTranslations(language: Language, translations: InterpolatableTranslationObject, shouldMerge: boolean): void;
+  deleteTranslations(language: Language): void;
+  getTranslationValue(language: Language, key: string): unknown;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TranslateStore, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<TranslateStore>;
+}
+//#endregion
+//# sourceMappingURL=translateStore.d.ts.map

package/dist/types/translateStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translateStore.d.ts","names":[],"sources":["../../src/translateStore.ts"],"mappings":";;;;;;;qBAkBa;mBACM;WAGR,cAAY,GAAA,OAAA,eAAA;mBAEJ;WAER,mCAAkB,WAJN;EAMrB,gBAAgB,UAAU,WAAW;EAIrC,gBACE,UAAU,UACV,cAAc,iCACd;EAeF,mBAAmB,UAAU;EAI7B,oBAAoB,UAAU,UAAU;SAIjC,MAAM,GAAG,qBAAqB;SAS9B,OAAO,GAAG,wBAAwB"}

package/dist/types/types.d.ts

@@ -0,0 +1,56 @@
+import { Provider } from "@angular/core";
+//#region src/types.d.ts
+export type Language = string;
+/** A compiled translation: a string, or a function of the parameters. */
+export type InterpolateFunction = (params?: InterpolationParameters) => string;
+export type InterpolationParameters = Record<string, unknown>;
+export type TranslationObject = {
+  [key: string]: Translation;
+};
+export type Translation = string | number | boolean | null | TranslationObject | Translation[];
+export type StrictTranslation = Exclude<Translation, null>;
+export type InterpolatableTranslation = string | InterpolateFunction | InterpolatableTranslationObject | InterpolatableTranslation[];
+export type InterpolatableTranslationObject = {
+  [key: string]: InterpolatableTranslation;
+};
+export type DeepReadonly<T> = T extends (infer R)[] ? ReadonlyArray<DeepReadonly<R>> : T extends ((...args: never[]) => unknown) ? T : T extends object ? { readonly [P in keyof T]: DeepReadonly<T[P]>; } : T;
+export type LangChangeEvent = {
+  lang: Language;
+  translations: InterpolatableTranslationObject;
+};
+export type TranslationChangeEvent = LangChangeEvent;
+export type FallbackLangChangeEvent = {
+  lang: Language;
+  translations: InterpolatableTranslationObject;
+};
+/** @deprecated Use {@link FallbackLangChangeEvent}. */
+export type DefaultLangChangeEvent = FallbackLangChangeEvent;
+export type MissingTranslationHandlerParams = {
+  key: string;
+  translateService: unknown;
+  interpolateParams?: InterpolationParameters;
+};
+export type TranslateProvider = Provider;
+export type TranslateProviders = {
+  loader?: TranslateProvider;
+  compiler?: TranslateProvider;
+  parser?: TranslateProvider;
+  missingTranslationHandler?: TranslateProvider;
+};
+export type ChildTranslateServiceConfig = TranslateProviders & {
+  /** Kept for API parity: every service shares intlayer's locale. */
+  extend?: boolean;
+};
+export type RootTranslateServiceConfig = TranslateProviders & {
+  /** Language activated when the service is created. */
+  lang?: Language;
+  /** Language whose translations fill the gaps of the active one. */
+  fallbackLang?: Language;
+  /** @deprecated Use `fallbackLang`. */
+  defaultLanguage?: Language;
+  /** @deprecated Use `lang`. */
+  useDefaultLang?: boolean;
+};
+export type TranslateServiceConfig = RootTranslateServiceConfig;
+//#endregion
+//# sourceMappingURL=types.d.ts.map