angular-intlayer 5.5.4 → 5.5.6

package/dist/cjs/client/dictionary.service.cjs

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dictionary_service_exports = {};
+__export(dictionary_service_exports, {
+  DictionaryService: () => DictionaryService
+});
+module.exports = __toCommonJS(dictionary_service_exports);
+var import_core = require("@angular/core");
+var import_rxjs = require("rxjs");
+@((0, import_core.Injectable)({
+  providedIn: "root"
+}))
+class DictionaryService {
+  constructor(localeService) {
+    this.localeService = localeService;
+  }
+  dictionaryCache = /* @__PURE__ */ new Map();
+  getDictionary(dictionary, locale) {
+    const targetLocale = locale || this.localeService.currentLocale;
+    const cacheKey = `${dictionary.id}-${targetLocale}`;
+    if (this.dictionaryCache.has(cacheKey)) {
+      return this.dictionaryCache.get(cacheKey);
+    }
+    const result = dictionary.content || dictionary;
+    this.dictionaryCache.set(cacheKey, result);
+    return result;
+  }
+  getDictionary$(dictionary) {
+    return this.localeService.locale$.pipe(
+      (0, import_rxjs.map)((locale) => this.getDictionary(dictionary, locale))
+    );
+  }
+  getDictionaries$(dictionaries) {
+    return this.localeService.locale$.pipe(
+      (0, import_rxjs.map)(
+        (locale) => dictionaries.map((dict) => this.getDictionary(dict, locale))
+      )
+    );
+  }
+  clearCache() {
+    this.dictionaryCache.clear();
+  }
+  clearCacheForDictionary(dictionaryId) {
+    const keysToDelete = Array.from(this.dictionaryCache.keys()).filter(
+      (key) => key.startsWith(`${dictionaryId}-`)
+    );
+    keysToDelete.forEach((key) => this.dictionaryCache.delete(key));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DictionaryService
+});
+//# sourceMappingURL=dictionary.service.cjs.map

package/dist/cjs/client/dictionary.service.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/dictionary.service.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\nimport type { Locales } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/core';\nimport { Observable, map } from 'rxjs';\nimport { LocaleService } from './locale.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class DictionaryService {\n  private dictionaryCache = new Map<string, any>();\n\n  constructor(private localeService: LocaleService) {}\n\n  getDictionary<T extends Dictionary & { id: string }>(\n    dictionary: T,\n    locale?: Locales\n  ): any {\n    const targetLocale = locale || this.localeService.currentLocale;\n    const cacheKey = `${dictionary.id}-${targetLocale}`;\n\n    if (this.dictionaryCache.has(cacheKey)) {\n      return this.dictionaryCache.get(cacheKey);\n    }\n\n    // Use a simpler approach to avoid type complexity\n    const result = dictionary.content || dictionary;\n    this.dictionaryCache.set(cacheKey, result);\n\n    return result;\n  }\n\n  getDictionary$<T extends Dictionary & { id: string }>(\n    dictionary: T\n  ): Observable<any> {\n    return this.localeService.locale$.pipe(\n      map((locale) => this.getDictionary(dictionary, locale))\n    );\n  }\n\n  getDictionaries$(\n    dictionaries: (Dictionary & { id: string })[]\n  ): Observable<any[]> {\n    return this.localeService.locale$.pipe(\n      map((locale) =>\n        dictionaries.map((dict) => this.getDictionary(dict, locale))\n      )\n    );\n  }\n\n  clearCache(): void {\n    this.dictionaryCache.clear();\n  }\n\n  clearCacheForDictionary(dictionaryId: string): void {\n    const keysToDelete = Array.from(this.dictionaryCache.keys()).filter((key) =>\n      key.startsWith(`${dictionaryId}-`)\n    );\n\n    keysToDelete.forEach((key) => this.dictionaryCache.delete(key));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA2B;AAG3B,kBAAgC;AAGhC,MAAC,wBAAW;AAAA,EACV,YAAY;AACd,CAAC;AACM,MAAM,kBAAkB;AAAA,EAG7B,YAAoB,eAA8B;AAA9B;AAAA,EAA+B;AAAA,EAF3C,kBAAkB,oBAAI,IAAiB;AAAA,EAI/C,cACE,YACA,QACK;AACL,UAAM,eAAe,UAAU,KAAK,cAAc;AAClD,UAAM,WAAW,GAAG,WAAW,EAAE,IAAI,YAAY;AAEjD,QAAI,KAAK,gBAAgB,IAAI,QAAQ,GAAG;AACtC,aAAO,KAAK,gBAAgB,IAAI,QAAQ;AAAA,IAC1C;AAGA,UAAM,SAAS,WAAW,WAAW;AACrC,SAAK,gBAAgB,IAAI,UAAU,MAAM;AAEzC,WAAO;AAAA,EACT;AAAA,EAEA,eACE,YACiB;AACjB,WAAO,KAAK,cAAc,QAAQ;AAAA,UAChC,iBAAI,CAAC,WAAW,KAAK,cAAc,YAAY,MAAM,CAAC;AAAA,IACxD;AAAA,EACF;AAAA,EAEA,iBACE,cACmB;AACnB,WAAO,KAAK,cAAc,QAAQ;AAAA,UAChC;AAAA,QAAI,CAAC,WACH,aAAa,IAAI,CAAC,SAAS,KAAK,cAAc,MAAM,MAAM,CAAC;AAAA,MAC7D;AAAA,IACF;AAAA,EACF;AAAA,EAEA,aAAmB;AACjB,SAAK,gBAAgB,MAAM;AAAA,EAC7B;AAAA,EAEA,wBAAwB,cAA4B;AAClD,UAAM,eAAe,MAAM,KAAK,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,MAAO,CAAC,QACnE,IAAI,WAAW,GAAG,YAAY,GAAG;AAAA,IACnC;AAEA,iBAAa,QAAQ,CAAC,QAAQ,KAAK,gBAAgB,OAAO,GAAG,CAAC;AAAA,EAChE;AACF;","names":[]}

package/dist/cjs/client/getBrowserLocale.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getBrowserLocale_exports = {};
+__export(getBrowserLocale_exports, {
+  getBrowserLocale: () => getBrowserLocale
+});
+module.exports = __toCommonJS(getBrowserLocale_exports);
+const getBrowserLocale = () => {
+  if (typeof window !== "undefined" && window.navigator) {
+    return window.navigator.language.split("-")[0];
+  }
+  return void 0;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBrowserLocale
+});
+//# sourceMappingURL=getBrowserLocale.cjs.map

package/dist/cjs/client/getBrowserLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/getBrowserLocale.ts"],"sourcesContent":["import { Locales } from '@intlayer/config';\n\n/**\n * Get the locale from the browser\n */\nexport const getBrowserLocale = (): Locales | undefined => {\n  if (typeof window !== 'undefined' && window.navigator) {\n    return window.navigator.language.split('-')[0] as Locales;\n  }\n  return undefined;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKO,MAAM,mBAAmB,MAA2B;AACzD,MAAI,OAAO,WAAW,eAAe,OAAO,WAAW;AACrD,WAAO,OAAO,UAAU,SAAS,MAAM,GAAG,EAAE,CAAC;AAAA,EAC/C;AACA,SAAO;AACT;","names":[]}

package/dist/cjs/client/getDictionary.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getDictionary_exports = {};
+__export(getDictionary_exports, {
+  getDictionary: () => getDictionary
+});
+module.exports = __toCommonJS(getDictionary_exports);
+var import_core = require("@intlayer/core");
+var import_plugins = require('../plugins.cjs');
+const getDictionary = (dictionary, locale, additionalPlugins) => {
+  const plugins = [
+    import_plugins.intlayerNodePlugins,
+    import_plugins.angularTemplatePlugin,
+    import_plugins.markdownPlugin,
+    ...additionalPlugins ?? []
+  ];
+  return (0, import_core.getDictionary)(
+    dictionary,
+    locale,
+    plugins
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDictionary
+});
+//# sourceMappingURL=getDictionary.cjs.map

package/dist/cjs/client/getDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/getDictionary.ts"],"sourcesContent":["import type { Locales, LocalesValues } from '@intlayer/config';\nimport {\n  type Dictionary,\n  type Plugins,\n  getDictionary as getDictionaryCore,\n} from '@intlayer/core';\nimport {\n  type DeepTransformContent,\n  angularTemplatePlugin,\n  intlayerNodePlugins,\n  markdownPlugin,\n} from '../plugins';\n\n/**\n * Get dictionary content for a specific locale\n */\nexport const getDictionary = <\n  T extends Dictionary,\n  L extends LocalesValues = Locales,\n>(\n  dictionary: T,\n  locale?: L,\n  additionalPlugins?: Plugins[]\n) => {\n  const plugins: Plugins[] = [\n    intlayerNodePlugins,\n    angularTemplatePlugin,\n    markdownPlugin,\n    ...(additionalPlugins ?? []),\n  ];\n\n  return getDictionaryCore(\n    dictionary,\n    locale,\n    plugins\n  ) as any as DeepTransformContent<T['content']>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAIO;AACP,qBAKO;AAKA,MAAM,gBAAgB,CAI3B,YACA,QACA,sBACG;AACH,QAAM,UAAqB;AAAA,IACzB;AAAA,IACA;AAAA,IACA;AAAA,IACA,GAAI,qBAAqB,CAAC;AAAA,EAC5B;AAEA,aAAO,YAAAA;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":["getDictionaryCore"]}

package/dist/cjs/client/getLocale.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getLocale_exports = {};
+__export(getLocale_exports, {
+  getLocale: () => getLocale
+});
+module.exports = __toCommonJS(getLocale_exports);
+const getLocale = () => {
+  return "en";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLocale
+});
+//# sourceMappingURL=getLocale.cjs.map

package/dist/cjs/client/getLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/getLocale.ts"],"sourcesContent":["import type { Locales } from '@intlayer/config';\n\n/**\n * Get the current locale\n * This is a basic implementation that can be extended with Angular services\n */\nexport const getLocale = (): Locales => {\n  // This is a placeholder implementation\n  // In a real Angular app, this would likely use a service or injection\n  return 'en' as Locales;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,MAAM,YAAY,MAAe;AAGtC,SAAO;AACT;","names":[]}

package/dist/cjs/client/index.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_exports = {};
+__export(client_exports, {
+  DictionaryService: () => import_dictionary.DictionaryService,
+  IntlayerService: () => import_intlayer.IntlayerService,
+  LocaleService: () => import_locale.LocaleService,
+  getBrowserLocale: () => import_getBrowserLocale.getBrowserLocale,
+  getDictionary: () => import_getDictionary.getDictionary,
+  getLocale: () => import_getLocale.getLocale,
+  t: () => import_t.t
+});
+module.exports = __toCommonJS(client_exports);
+var import_dictionary = require('./dictionary.service.cjs');
+var import_getBrowserLocale = require('./getBrowserLocale.cjs');
+var import_getDictionary = require('./getDictionary.cjs');
+var import_getLocale = require('./getLocale.cjs');
+var import_intlayer = require('./intlayer.service.cjs');
+var import_locale = require('./locale.service.cjs');
+var import_t = require('./t.cjs');
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DictionaryService,
+  IntlayerService,
+  LocaleService,
+  getBrowserLocale,
+  getDictionary,
+  getLocale,
+  t
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/client/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/index.ts"],"sourcesContent":["export { DictionaryService } from './dictionary.service';\nexport { getBrowserLocale } from './getBrowserLocale';\nexport { getDictionary } from './getDictionary';\nexport { getLocale } from './getLocale';\nexport { IntlayerService } from './intlayer.service';\nexport { LocaleService } from './locale.service';\nexport { t } from './t';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAAkC;AAClC,8BAAiC;AACjC,2BAA8B;AAC9B,uBAA0B;AAC1B,sBAAgC;AAChC,oBAA8B;AAC9B,eAAkB;","names":[]}

package/dist/cjs/client/intlayer.service.cjs

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var intlayer_service_exports = {};
+__export(intlayer_service_exports, {
+  IntlayerService: () => IntlayerService
+});
+module.exports = __toCommonJS(intlayer_service_exports);
+var import_core = require("@angular/core");
+var import_rxjs = require("rxjs");
+@((0, import_core.Injectable)({
+  providedIn: "root"
+}))
+class IntlayerService {
+  localeSubject = new import_rxjs.BehaviorSubject("en");
+  locale$ = this.localeSubject.asObservable();
+  get currentLocale() {
+    return this.localeSubject.value;
+  }
+  setLocale(locale) {
+    this.localeSubject.next(locale);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IntlayerService
+});
+//# sourceMappingURL=intlayer.service.cjs.map

package/dist/cjs/client/intlayer.service.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/intlayer.service.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\nimport type { Locales } from '@intlayer/config';\nimport { BehaviorSubject } from 'rxjs';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class IntlayerService {\n  private localeSubject = new BehaviorSubject<Locales>('en' as Locales);\n  public locale$ = this.localeSubject.asObservable();\n\n  get currentLocale(): Locales {\n    return this.localeSubject.value;\n  }\n\n  setLocale(locale: Locales): void {\n    this.localeSubject.next(locale);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA2B;AAE3B,kBAAgC;AAEhC,MAAC,wBAAW;AAAA,EACV,YAAY;AACd,CAAC;AACM,MAAM,gBAAgB;AAAA,EACnB,gBAAgB,IAAI,4BAAyB,IAAe;AAAA,EAC7D,UAAU,KAAK,cAAc,aAAa;AAAA,EAEjD,IAAI,gBAAyB;AAC3B,WAAO,KAAK,cAAc;AAAA,EAC5B;AAAA,EAEA,UAAU,QAAuB;AAC/B,SAAK,cAAc,KAAK,MAAM;AAAA,EAChC;AACF;","names":[]}

package/dist/cjs/client/locale.service.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var locale_service_exports = {};
+__export(locale_service_exports, {
+  LocaleService: () => LocaleService
+});
+module.exports = __toCommonJS(locale_service_exports);
+var import_core = require("@angular/core");
+var import_rxjs = require("rxjs");
+var import_getBrowserLocale = require('./getBrowserLocale.cjs');
+@((0, import_core.Injectable)({
+  providedIn: "root"
+}))
+class LocaleService {
+  localeSubject = new import_rxjs.BehaviorSubject(
+    (0, import_getBrowserLocale.getBrowserLocale)() || "en"
+  );
+  locale$ = this.localeSubject.asObservable();
+  constructor() {
+    const browserLocale = (0, import_getBrowserLocale.getBrowserLocale)();
+    if (browserLocale) {
+      this.setLocale(browserLocale);
+    }
+  }
+  get currentLocale() {
+    return this.localeSubject.value;
+  }
+  setLocale(locale) {
+    this.localeSubject.next(locale);
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem("intlayer-locale", locale);
+    }
+  }
+  getStoredLocale() {
+    if (typeof localStorage !== "undefined") {
+      return localStorage.getItem("intlayer-locale");
+    }
+    return null;
+  }
+  clearStoredLocale() {
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem("intlayer-locale");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocaleService
+});
+//# sourceMappingURL=locale.service.cjs.map

package/dist/cjs/client/locale.service.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/locale.service.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\nimport type { Locales } from '@intlayer/config';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { getBrowserLocale } from './getBrowserLocale';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class LocaleService {\n  private localeSubject = new BehaviorSubject<Locales>(\n    getBrowserLocale() || ('en' as Locales)\n  );\n\n  public locale$: Observable<Locales> = this.localeSubject.asObservable();\n\n  constructor() {\n    // Initialize with browser locale if available\n    const browserLocale = getBrowserLocale();\n    if (browserLocale) {\n      this.setLocale(browserLocale);\n    }\n  }\n\n  get currentLocale(): Locales {\n    return this.localeSubject.value;\n  }\n\n  setLocale(locale: Locales): void {\n    this.localeSubject.next(locale);\n\n    // Optionally store in localStorage for persistence\n    if (typeof localStorage !== 'undefined') {\n      localStorage.setItem('intlayer-locale', locale);\n    }\n  }\n\n  getStoredLocale(): Locales | null {\n    if (typeof localStorage !== 'undefined') {\n      return localStorage.getItem('intlayer-locale') as Locales;\n    }\n    return null;\n  }\n\n  clearStoredLocale(): void {\n    if (typeof localStorage !== 'undefined') {\n      localStorage.removeItem('intlayer-locale');\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA2B;AAE3B,kBAA4C;AAC5C,8BAAiC;AAEjC,MAAC,wBAAW;AAAA,EACV,YAAY;AACd,CAAC;AACM,MAAM,cAAc;AAAA,EACjB,gBAAgB,IAAI;AAAA,QAC1B,0CAAiB,KAAM;AAAA,EACzB;AAAA,EAEO,UAA+B,KAAK,cAAc,aAAa;AAAA,EAEtE,cAAc;AAEZ,UAAM,oBAAgB,0CAAiB;AACvC,QAAI,eAAe;AACjB,WAAK,UAAU,aAAa;AAAA,IAC9B;AAAA,EACF;AAAA,EAEA,IAAI,gBAAyB;AAC3B,WAAO,KAAK,cAAc;AAAA,EAC5B;AAAA,EAEA,UAAU,QAAuB;AAC/B,SAAK,cAAc,KAAK,MAAM;AAG9B,QAAI,OAAO,iBAAiB,aAAa;AACvC,mBAAa,QAAQ,mBAAmB,MAAM;AAAA,IAChD;AAAA,EACF;AAAA,EAEA,kBAAkC;AAChC,QAAI,OAAO,iBAAiB,aAAa;AACvC,aAAO,aAAa,QAAQ,iBAAiB;AAAA,IAC/C;AACA,WAAO;AAAA,EACT;AAAA,EAEA,oBAA0B;AACxB,QAAI,OAAO,iBAAiB,aAAa;AACvC,mBAAa,WAAW,iBAAiB;AAAA,IAC3C;AAAA,EACF;AACF;","names":[]}

package/dist/cjs/client/t.cjs

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var t_exports = {};
+__export(t_exports, {
+  t: () => t
+});
+module.exports = __toCommonJS(t_exports);
+var import_core = require("@intlayer/core");
+const t = (multilangContent, locale) => {
+  return (0, import_core.getTranslation)(multilangContent, locale);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  t
+});
+//# sourceMappingURL=t.cjs.map

package/dist/cjs/client/t.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/t.ts"],"sourcesContent":["import type { Locales } from '@intlayer/config';\nimport { type LanguageContent, getTranslation } from '@intlayer/core';\n\n/**\n * Translation function for Angular applications\n * Returns the translation of the provided multilang content\n */\nexport const t = <Content = string>(\n  multilangContent: LanguageContent<Content>,\n  locale: Locales\n) => {\n  return getTranslation<Content>(multilangContent, locale);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,kBAAqD;AAM9C,MAAM,IAAI,CACf,kBACA,WACG;AACH,aAAO,4BAAwB,kBAAkB,MAAM;AACzD;","names":[]}

package/dist/cjs/getDictionary.cjs

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getDictionary_exports = {};
+__export(getDictionary_exports, {
+  getDictionary: () => import_getDictionary.getDictionary
+});
+module.exports = __toCommonJS(getDictionary_exports);
+var import_getDictionary = require('./client/getDictionary.cjs');
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDictionary
+});
+//# sourceMappingURL=getDictionary.cjs.map

package/dist/cjs/getDictionary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/getDictionary.ts"],"sourcesContent":["export { getDictionary } from './client/getDictionary';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAA8B;","names":[]}

package/dist/cjs/getIntlayer.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getIntlayer_exports = {};
+__export(getIntlayer_exports, {
+  getIntlayer: () => getIntlayer
+});
+module.exports = __toCommonJS(getIntlayer_exports);
+const getIntlayer = (dictionary, locale, additionalPlugins) => {
+  return dictionary.content || dictionary;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getIntlayer
+});
+//# sourceMappingURL=getIntlayer.cjs.map

package/dist/cjs/getIntlayer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/getIntlayer.ts"],"sourcesContent":["import type { Locales, LocalesValues } from '@intlayer/config';\nimport type { Dictionary, Plugins } from '@intlayer/core';\n\n/**\n * Function to get the content of a dictionary for Angular applications\n */\nexport const getIntlayer = <\n  T extends Dictionary,\n  L extends LocalesValues = Locales,\n>(\n  dictionary: T,\n  locale: L,\n  additionalPlugins?: Plugins[]\n): any => {\n  // Simplified implementation to avoid type complexity\n  return dictionary.content || dictionary;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,MAAM,cAAc,CAIzB,YACA,QACA,sBACQ;AAER,SAAO,WAAW,WAAW;AAC/B;","names":[]}

package/dist/cjs/index.cjs

@@ -15,11 +15,17 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 module.exports = __toCommonJS(index_exports);
-__reExport(index_exports, require('./intlayerPlugin.cjs'), module.exports);
-__reExport(index_exports, require('./intlayerMiddlewarePlugin.cjs'), module.exports);
+__reExport(index_exports, require('./client/index.cjs'), module.exports);
+__reExport(index_exports, require('./getDictionary.cjs'), module.exports);
+__reExport(index_exports, require('./getIntlayer.cjs'), module.exports);
+__reExport(index_exports, require('./markdown/index.cjs'), module.exports);
+__reExport(index_exports, require('./plugins.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require('./intlayerPlugin.cjs'),
-  ...require('./intlayerMiddlewarePlugin.cjs')
+  ...require('./client/index.cjs'),
+  ...require('./getDictionary.cjs'),
+  ...require('./getIntlayer.cjs'),
+  ...require('./markdown/index.cjs'),
+  ...require('./plugins.cjs')
 });
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * from './intlayerPlugin';\nexport * from './intlayerMiddlewarePlugin';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,6BAAd;AACA,0BAAc,uCADd;","names":[]}
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import { IInterpreterPluginAngular } from './plugins';\n\ndeclare module '@intlayer/core' {\n  interface IInterpreterPlugin<T, S> extends IInterpreterPluginAngular<T> {}\n}\n\nexport * from './client';\nexport * from './getDictionary';\nexport * from './getIntlayer';\nexport * from './markdown';\nexport * from './plugins';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAMA,0BAAc,qBANd;AAOA,0BAAc,4BAPd;AAQA,0BAAc,0BARd;AASA,0BAAc,uBATd;AAUA,0BAAc,sBAVd;","names":[]}

package/dist/cjs/markdown/index.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var markdown_exports = {};
+__export(markdown_exports, {
+  MarkdownModule: () => MarkdownModule,
+  renderMarkdown: () => renderMarkdown
+});
+module.exports = __toCommonJS(markdown_exports);
+const renderMarkdown = (content) => {
+  return content;
+};
+const MarkdownModule = {
+  renderMarkdown
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MarkdownModule,
+  renderMarkdown
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/markdown/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/markdown/index.ts"],"sourcesContent":["// Basic markdown support for Angular\n// This could be extended with Angular-specific markdown components\n\nexport const renderMarkdown = (content: string): string => {\n  // Basic implementation - in a real app this might use a markdown library\n  return content;\n};\n\nexport const MarkdownModule = {\n  renderMarkdown,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,MAAM,iBAAiB,CAAC,YAA4B;AAEzD,SAAO;AACT;AAEO,MAAM,iBAAiB;AAAA,EAC5B;AACF;","names":[]}