@odx/angular 6.0.0 → 6.1.0

package/esm2022/lib/services/window-ref.mjs

@@ -6,43 +6,109 @@ import { fromEvents } from '@odx/angular/rxjs';
 import { getLanguageCode } from '@odx/angular/utils';
 import { debounceTime, distinctUntilChanged, EMPTY, filter, map, shareReplay, startWith } from 'rxjs';
 import * as i0 from "@angular/core";
+/**
+ * A service that wraps window and document functionalities, providing Angular-friendly ways to interact with the browser's window object,
+ * manage the document and its title, listen to online/offline events, and perform other browser-related operations.
+ */
 export class WindowRef {
     constructor() {
         this.title = inject(Title);
+        /**
+         * Accesses the document object, ensuring Angular compatibility and potential SSR friendliness.
+         */
         this.document = inject(DOCUMENT);
+        /**
+         * Retrieves the native window object, with a fallback to the global window if necessary.
+         * This approach helps ensure compatibility with Angular's SSR features.
+         */
         this.nativeWindow = this.document.defaultView ?? window;
+        /**
+         * An observable that emits the online status of the browser, updating when the browser transitions between online and offline states.
+         */
         this.isOnline$ = fromEvents(this.nativeWindow, 'offline', 'online').pipe(startWith(null), map(() => this.isOnline()), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
+        /**
+         * An observable that emits the current page title upon navigation ends, useful for updating document titles in SPA applications.
+         */
         this.pageTitle$ = (inject(Router, { optional: true })?.events ?? EMPTY).pipe(filter((event) => event instanceof NavigationEnd), startWith(null), debounceTime(0), map(() => this.title.getTitle()), shareReplay({ bufferSize: 1, refCount: true }));
     }
+    /**
+     * Gets the location object of the window.
+     * @returns The location object of the window.
+     */
     get location() {
         return this.nativeWindow.location;
     }
+    /**
+     * Determines if the browser is currently online.
+     * @returns {boolean} True if the browser is online; otherwise, false.
+     */
     isOnline() {
         return this.nativeWindow.navigator.onLine;
     }
+    /**
+     * Retrieves the browser's current language setting, falling back through several browser-specific properties.
+     * @returns {string} The current language setting of the browser.
+     */
     getLanguage() {
         const { language, languages, userLanguage } = this.nativeWindow.navigator;
         return languages?.[0] ?? userLanguage ?? language;
     }
+    /**
+     * Extracts the language code from the browser's current language setting.
+     * @returns {string} The language code part of the browser's language setting.
+     */
     getLanguageCode() {
         return getLanguageCode(this.getLanguage());
     }
+    /**
+     * Returns the origin of the current window location.
+     *
+     * @returns The origin of the current window location.
+     */
     getOrigin() {
         return this.location.origin;
     }
+    /**
+     * Opens a new browser tab or window and navigates to the specified URL.
+     * @param {string | URL} [url] - The URL to open.
+     * @param {string} [target] - The target window or tab.
+     * @param {string} [features] - String that specifies the window features.
+     * @returns {WindowProxy | null} A reference to the newly opened window or null if the call failed.
+     */
     openPage(url, target, features) {
         return this.nativeWindow.open(url, target, features);
     }
+    /**
+     * Reloads the current page.
+     */
     reloadPage() {
         return this.location.reload();
     }
+    /**
+     * Queries the DOM for an element associated with a specific Angular component type.
+     * @template T The component type to query for.
+     * @param {Type<T>} type - The Angular component type.
+     * @returns {HTMLElement | null} The HTML element associated with the component, or null if not found.
+     */
     queryByComponent(type) {
         const componentType = reflectComponentType(type);
         return componentType ? this.nativeWindow.document.querySelector(componentType.selector) : null;
     }
+    /**
+     * Retrieves the value of a CSS variable on a specified element.
+     * @param {string} name - The name of the CSS variable.
+     * @param {HTMLElement} [element=this.document.body] - The element from which to retrieve the CSS variable.
+     * @returns {string} The value of the CSS variable.
+     */
     getCSSVariable(name, element = this.document.body) {
         return this.nativeWindow.getComputedStyle(element).getPropertyValue(`--${name}`).trim();
     }
+    /**
+     * Extracts CSS color styles that match a specific filter from the document's stylesheets.
+     * @param {string} filter - The filter to apply to CSS variable names.
+     * @param {string} [selector=':root'] - The CSS selector to filter by.
+     * @returns {Record<string, string>} A record containing the filtered CSS color styles.
+     */
     getCSSColorStyles(filter, selector = ':root') {
         const selectorFilter = new RegExp(`^${selector}$`);
         const nameFilter = new RegExp(`^--${filter}`);
@@ -71,4 +137,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"window-ref.js","sourceRoot":"","sources":["../../../../../../libs/angular/src/lib/services/window-ref.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { inject, Injectable, reflectComponentType, Type } from '@angular/core';\nimport { Title } from '@angular/platform-browser';\nimport { NavigationEnd, Router } from '@angular/router';\nimport { fromEvents } from '@odx/angular/rxjs';\nimport { getLanguageCode } from '@odx/angular/utils';\nimport { debounceTime, distinctUntilChanged, EMPTY, filter, map, shareReplay, startWith } from 'rxjs';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class WindowRef {\n  private readonly title = inject(Title);\n  public readonly document = inject(DOCUMENT);\n  public readonly nativeWindow = this.document.defaultView ?? window;\n  public readonly isOnline$ = fromEvents(this.nativeWindow, 'offline', 'online').pipe(\n    startWith(null),\n    map(() => this.isOnline()),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n  public readonly pageTitle$ = (inject(Router, { optional: true })?.events ?? EMPTY).pipe(\n    filter((event) => event instanceof NavigationEnd),\n    startWith(null),\n    debounceTime(0),\n    map(() => this.title.getTitle()),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  public get location(): Location {\n    return this.nativeWindow.location;\n  }\n\n  public isOnline(): boolean {\n    return this.nativeWindow.navigator.onLine;\n  }\n\n  public getLanguage(): string {\n    const { language, languages, userLanguage } = this.nativeWindow.navigator as Navigator & { userLanguage?: string };\n\n    return languages?.[0] ?? userLanguage ?? language;\n  }\n\n  public getLanguageCode(): string {\n    return getLanguageCode(this.getLanguage());\n  }\n\n  public getOrigin(): string {\n    return this.location.origin;\n  }\n\n  public openPage(url?: string | URL, target?: string, features?: string): WindowProxy | null {\n    return this.nativeWindow.open(url, target, features);\n  }\n\n  public reloadPage(): void {\n    return this.location.reload();\n  }\n\n  public queryByComponent<T>(type: Type<T>): HTMLElement | null {\n    const componentType = reflectComponentType(type);\n\n    return componentType ? this.nativeWindow.document.querySelector(componentType.selector) : null;\n  }\n\n  public getCSSVariable(name: string, element: HTMLElement = this.document.body): string {\n    return this.nativeWindow.getComputedStyle(element).getPropertyValue(`--${name}`).trim();\n  }\n\n  public getCSSColorStyles(filter: string, selector = ':root'): Record<string, string> {\n    const selectorFilter = new RegExp(`^${selector}$`);\n    const nameFilter = new RegExp(`^--${filter}`);\n    const arr = Array.from(this.document.styleSheets)\n      .filter(({ href }) => !href || href.startsWith(this.nativeWindow.location.origin))\n      .map(({ cssRules }) => Array.from(cssRules)[0])\n      .filter((rule) => rule instanceof CSSStyleRule && selectorFilter.test(rule.selectorText.trim()))\n      .reduce((colors: Record<string, string>, rule) => {\n        Object.values((rule as CSSStyleRule).style)\n          .map((style) => style.toString().trim())\n          .filter((name) => Boolean(name) && nameFilter.test(name))\n          .forEach((name) => {\n            const key = name.replace('--', '');\n            colors[key] = this.getCSSVariable(key);\n          });\n        return colors;\n      }, {});\n    return arr;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"window-ref.js","sourceRoot":"","sources":["../../../../../../libs/angular/src/lib/services/window-ref.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport { inject, Injectable, reflectComponentType, Type } from '@angular/core';\nimport { Title } from '@angular/platform-browser';\nimport { NavigationEnd, Router } from '@angular/router';\nimport { fromEvents } from '@odx/angular/rxjs';\nimport { getLanguageCode } from '@odx/angular/utils';\nimport { debounceTime, distinctUntilChanged, EMPTY, filter, map, shareReplay, startWith } from 'rxjs';\n\n/**\n * A service that wraps window and document functionalities, providing Angular-friendly ways to interact with the browser's window object,\n * manage the document and its title, listen to online/offline events, and perform other browser-related operations.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class WindowRef {\n  private readonly title = inject(Title);\n\n  /**\n   * Accesses the document object, ensuring Angular compatibility and potential SSR friendliness.\n   */\n  public readonly document = inject(DOCUMENT);\n\n  /**\n   * Retrieves the native window object, with a fallback to the global window if necessary.\n   * This approach helps ensure compatibility with Angular's SSR features.\n   */\n  public readonly nativeWindow = this.document.defaultView ?? window;\n\n  /**\n   * An observable that emits the online status of the browser, updating when the browser transitions between online and offline states.\n   */\n  public readonly isOnline$ = fromEvents(this.nativeWindow, 'offline', 'online').pipe(\n    startWith(null),\n    map(() => this.isOnline()),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * An observable that emits the current page title upon navigation ends, useful for updating document titles in SPA applications.\n   */\n  public readonly pageTitle$ = (inject(Router, { optional: true })?.events ?? EMPTY).pipe(\n    filter((event) => event instanceof NavigationEnd),\n    startWith(null),\n    debounceTime(0),\n    map(() => this.title.getTitle()),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * Gets the location object of the window.\n   * @returns The location object of the window.\n   */\n  public get location(): Location {\n    return this.nativeWindow.location;\n  }\n\n  /**\n   * Determines if the browser is currently online.\n   * @returns {boolean} True if the browser is online; otherwise, false.\n   */\n  public isOnline(): boolean {\n    return this.nativeWindow.navigator.onLine;\n  }\n\n  /**\n   * Retrieves the browser's current language setting, falling back through several browser-specific properties.\n   * @returns {string} The current language setting of the browser.\n   */\n  public getLanguage(): string {\n    const { language, languages, userLanguage } = this.nativeWindow.navigator as Navigator & { userLanguage?: string };\n\n    return languages?.[0] ?? userLanguage ?? language;\n  }\n\n  /**\n   * Extracts the language code from the browser's current language setting.\n   * @returns {string} The language code part of the browser's language setting.\n   */\n  public getLanguageCode(): string {\n    return getLanguageCode(this.getLanguage());\n  }\n\n  /**\n   * Returns the origin of the current window location.\n   *\n   * @returns The origin of the current window location.\n   */\n  public getOrigin(): string {\n    return this.location.origin;\n  }\n\n  /**\n   * Opens a new browser tab or window and navigates to the specified URL.\n   * @param {string | URL} [url] - The URL to open.\n   * @param {string} [target] - The target window or tab.\n   * @param {string} [features] - String that specifies the window features.\n   * @returns {WindowProxy | null} A reference to the newly opened window or null if the call failed.\n   */\n  public openPage(url?: string | URL, target?: string, features?: string): WindowProxy | null {\n    return this.nativeWindow.open(url, target, features);\n  }\n\n  /**\n   * Reloads the current page.\n   */\n  public reloadPage(): void {\n    return this.location.reload();\n  }\n\n  /**\n   * Queries the DOM for an element associated with a specific Angular component type.\n   * @template T The component type to query for.\n   * @param {Type<T>} type - The Angular component type.\n   * @returns {HTMLElement | null} The HTML element associated with the component, or null if not found.\n   */\n  public queryByComponent<T>(type: Type<T>): HTMLElement | null {\n    const componentType = reflectComponentType(type);\n\n    return componentType ? this.nativeWindow.document.querySelector(componentType.selector) : null;\n  }\n\n  /**\n   * Retrieves the value of a CSS variable on a specified element.\n   * @param {string} name - The name of the CSS variable.\n   * @param {HTMLElement} [element=this.document.body] - The element from which to retrieve the CSS variable.\n   * @returns {string} The value of the CSS variable.\n   */\n  public getCSSVariable(name: string, element: HTMLElement = this.document.body): string {\n    return this.nativeWindow.getComputedStyle(element).getPropertyValue(`--${name}`).trim();\n  }\n\n  /**\n   * Extracts CSS color styles that match a specific filter from the document's stylesheets.\n   * @param {string} filter - The filter to apply to CSS variable names.\n   * @param {string} [selector=':root'] - The CSS selector to filter by.\n   * @returns {Record<string, string>} A record containing the filtered CSS color styles.\n   */\n  public getCSSColorStyles(filter: string, selector = ':root'): Record<string, string> {\n    const selectorFilter = new RegExp(`^${selector}$`);\n    const nameFilter = new RegExp(`^--${filter}`);\n    const arr = Array.from(this.document.styleSheets)\n      .filter(({ href }) => !href || href.startsWith(this.nativeWindow.location.origin))\n      .map(({ cssRules }) => Array.from(cssRules)[0])\n      .filter((rule) => rule instanceof CSSStyleRule && selectorFilter.test(rule.selectorText.trim()))\n      .reduce((colors: Record<string, string>, rule) => {\n        Object.values((rule as CSSStyleRule).style)\n          .map((style) => style.toString().trim())\n          .filter((name) => Boolean(name) && nameFilter.test(name))\n          .forEach((name) => {\n            const key = name.replace('--', '');\n            colors[key] = this.getCSSVariable(key);\n          });\n        return colors;\n      }, {});\n    return arr;\n  }\n}\n"]}

package/esm2022/lib/tokens/identity-matcher.mjs

@@ -1,7 +1,31 @@
 import { InjectionToken } from '@angular/core';
 const ODX_DEFAULT_IDENTITY_MATCHER = (item1, item2) => item1 === item2;
+/**
+ * An Angular `InjectionToken` for the `IdentityMatcher` function, allowing for the provision
+ * and injection of custom identity matching logic throughout the application. The token is
+ * provided with a default factory function that returns the `ODX_DEFAULT_IDENTITY_MATCHER`,
+ * which can be overridden with custom logic as needed.
+ *
+ * @type {InjectionToken<IdentityMatcher<unknown>>}
+ *
+ * @example
+ * ```ts
+ * // Providing a custom identity matcher in an Angular module
+ * @NgModule({
+ *   providers: [
+ *     { provide: ODX_IDENTITY_MATCHER, useValue: (item1, item2) => item1.id === item2.id }
+ *   ]
+ * })
+ * class AppModule {}
+ *
+ * // Injecting and using the custom provided identity matcher
+ * constructor(@Inject(ODX_IDENTITY_MATCHER) private identityMatcher: IdentityMatcher<MyType>) {
+ *   console.log(this.identityMatcher({ id: 1 }, { id: 1 })); // Depends on the custom logic provided
+ * }
+ * ```
+ */
 export const ODX_IDENTITY_MATCHER = new InjectionToken('@odx/angular::StringHandler', {
     providedIn: 'root',
     factory: () => ODX_DEFAULT_IDENTITY_MATCHER,
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWRlbnRpdHktbWF0Y2hlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9zcmMvbGliL3Rva2Vucy9pZGVudGl0eS1tYXRjaGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFJL0MsTUFBTSw0QkFBNEIsR0FBNkIsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxLQUFLLEtBQUssS0FBSyxDQUFDO0FBRWpHLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLElBQUksY0FBYyxDQUEyQiw2QkFBNkIsRUFBRTtJQUM5RyxVQUFVLEVBQUUsTUFBTTtJQUNsQixPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMsNEJBQTRCO0NBQzVDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCB0eXBlIElkZW50aXR5TWF0Y2hlcjxUPiA9IChpdGVtMTogVCwgaXRlbTI6IFQpID0+IGJvb2xlYW47XG5cbmNvbnN0IE9EWF9ERUZBVUxUX0lERU5USVRZX01BVENIRVI6IElkZW50aXR5TWF0Y2hlcjx1bmtub3duPiA9IChpdGVtMSwgaXRlbTIpID0+IGl0ZW0xID09PSBpdGVtMjtcblxuZXhwb3J0IGNvbnN0IE9EWF9JREVOVElUWV9NQVRDSEVSID0gbmV3IEluamVjdGlvblRva2VuPElkZW50aXR5TWF0Y2hlcjx1bmtub3duPj4oJ0BvZHgvYW5ndWxhcjo6U3RyaW5nSGFuZGxlcicsIHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxuICBmYWN0b3J5OiAoKSA9PiBPRFhfREVGQVVMVF9JREVOVElUWV9NQVRDSEVSLFxufSk7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tokens/string-search-handler.mjs

@@ -2,8 +2,32 @@ import { InjectionToken } from '@angular/core';
 const ODX_DEFAULT_STRING_SEARCH_HANDLER = (item, query) => {
     return item.toLocaleLowerCase().includes(query.toLocaleLowerCase());
 };
+/**
+ * An Angular `InjectionToken` for the `StringSearchHandler` function, allowing for the provision
+ * and injection of custom string search logic throughout the application. This token is provided with
+ * a default factory function that returns the `ODX_DEFAULT_STRING_SEARCH_HANDLER`, which can be overridden
+ * with custom logic as needed.
+ *
+ * @type {InjectionToken<StringSearchHandler>}
+ *
+ * @example
+ * ```ts
+ * // Providing a custom string search handler in an Angular module
+ * @NgModule({
+ *   providers: [
+ *     { provide: ODX_STRING_SEARCH_HANDLER, useValue: (item, query) => item.startsWith(query) }
+ *   ]
+ * })
+ * class AppModule {}
+ *
+ * // Injecting and using the custom provided string search handler
+ * constructor(@Inject(ODX_STRING_SEARCH_HANDLER) private searchHandler: StringSearchHandler) {
+ *   console.log(this.searchHandler('Angular', 'A')); // Depends on the custom logic provided
+ * }
+ * ```
+ */
 export const ODX_STRING_SEARCH_HANDLER = new InjectionToken('@odx/angular::StringHandler', {
     providedIn: 'root',
     factory: () => ODX_DEFAULT_STRING_SEARCH_HANDLER,
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5nLXNlYXJjaC1oYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3NyYy9saWIvdG9rZW5zL3N0cmluZy1zZWFyY2gtaGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBSS9DLE1BQU0saUNBQWlDLEdBQXdCLENBQUMsSUFBSSxFQUFFLEtBQUssRUFBRSxFQUFFO0lBQzdFLE9BQU8sSUFBSSxDQUFDLGlCQUFpQixFQUFFLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLENBQUM7QUFDdEUsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsSUFBSSxjQUFjLENBQXNCLDZCQUE2QixFQUFFO0lBQzlHLFVBQVUsRUFBRSxNQUFNO0lBQ2xCLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxpQ0FBaUM7Q0FDakQsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IHR5cGUgU3RyaW5nU2VhcmNoSGFuZGxlciA9IChpdGVtOiBzdHJpbmcsIHF1ZXJ5OiBzdHJpbmcpID0+IGJvb2xlYW47XG5cbmNvbnN0IE9EWF9ERUZBVUxUX1NUUklOR19TRUFSQ0hfSEFORExFUjogU3RyaW5nU2VhcmNoSGFuZGxlciA9IChpdGVtLCBxdWVyeSkgPT4ge1xuICByZXR1cm4gaXRlbS50b0xvY2FsZUxvd2VyQ2FzZSgpLmluY2x1ZGVzKHF1ZXJ5LnRvTG9jYWxlTG93ZXJDYXNlKCkpO1xufTtcblxuZXhwb3J0IGNvbnN0IE9EWF9TVFJJTkdfU0VBUkNIX0hBTkRMRVIgPSBuZXcgSW5qZWN0aW9uVG9rZW48U3RyaW5nU2VhcmNoSGFuZGxlcj4oJ0BvZHgvYW5ndWxhcjo6U3RyaW5nSGFuZGxlcicsIHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxuICBmYWN0b3J5OiAoKSA9PiBPRFhfREVGQVVMVF9TVFJJTkdfU0VBUkNIX0hBTkRMRVIsXG59KTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tokens/stringify.mjs

@@ -1,8 +1,33 @@
 import { InjectionToken } from '@angular/core';
 import { isPresent } from '@odx/angular/utils';
 const ODX_DEFAULT_STRINGIFY = (item) => (isPresent(item) ? String(item) : '');
+/**
+ * An Angular `InjectionToken` for the `StringifyFn` function, allowing the injection of custom
+ * stringification logic throughout an application. By default, it is provided with a factory
+ * function that returns `ODX_DEFAULT_STRINGIFY`. This setup permits easy customization of
+ * how items are converted to strings, facilitating different stringification strategies
+ * for various application needs.
+ *
+ * @type {InjectionToken<StringifyFn<unknown>>}
+ *
+ * @example
+ * ```ts
+ * // Providing a custom stringify function in an Angular module
+ * @NgModule({
+ *   providers: [
+ *     { provide: ODX_STRINGIFY, useValue: (item) => JSON.stringify(item) }
+ *   ]
+ * })
+ * class AppModule {}
+ *
+ * // Injecting and using the custom provided stringify function
+ * constructor(@Inject(ODX_STRINGIFY) private stringify: StringifyFn<unknown>) {
+ *   console.log(this.stringify({ key: 'value' })); // Outputs: '{"key":"value"}'
+ * }
+ * ```
+ */
 export const ODX_STRINGIFY = new InjectionToken('@odx/angular::Stringify', {
     providedIn: 'root',
     factory: () => ODX_DEFAULT_STRINGIFY,
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5naWZ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3NyYy9saWIvdG9rZW5zL3N0cmluZ2lmeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQy9DLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUkvQyxNQUFNLHFCQUFxQixHQUF5QixDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUM7QUFFcEcsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLElBQUksY0FBYyxDQUF1Qix5QkFBeUIsRUFBRTtJQUMvRixVQUFVLEVBQUUsTUFBTTtJQUNsQixPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMscUJBQXFCO0NBQ3JDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBpc1ByZXNlbnQgfSBmcm9tICdAb2R4L2FuZ3VsYXIvdXRpbHMnO1xuXG5leHBvcnQgdHlwZSBTdHJpbmdpZnlGbjxUPiA9IChpdGVtOiBUKSA9PiBzdHJpbmc7XG5cbmNvbnN0IE9EWF9ERUZBVUxUX1NUUklOR0lGWTogU3RyaW5naWZ5Rm48dW5rbm93bj4gPSAoaXRlbSkgPT4gKGlzUHJlc2VudChpdGVtKSA/IFN0cmluZyhpdGVtKSA6ICcnKTtcblxuZXhwb3J0IGNvbnN0IE9EWF9TVFJJTkdJRlkgPSBuZXcgSW5qZWN0aW9uVG9rZW48U3RyaW5naWZ5Rm48dW5rbm93bj4+KCdAb2R4L2FuZ3VsYXI6OlN0cmluZ2lmeScsIHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxuICBmYWN0b3J5OiAoKSA9PiBPRFhfREVGQVVMVF9TVFJJTkdJRlksXG59KTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/localization/lib/features/with-http-language-header.mjs

@@ -5,6 +5,33 @@ import { switchMap, take } from 'rxjs';
 import { LocalizationService } from '../localization.service';
 import { makeLocalizationFeature } from '../models';
 export const HTTP_LANGUAGE_HEADER = 'Accept-Language';
+/**
+ * Creates an HTTP interceptor function that adds a language header to outgoing HTTP requests,
+ * but only for URLs matching the provided criteria. This allows the server to respond with
+ * resources localized in the user's current language.
+ *
+ * @param {HttpLanguageHeaderInterceptorConfig} config - The configuration for the interceptor,
+ * including the list of allowed URLs and optionally a custom header name.
+ * @returns {HttpInterceptorFn} An Angular HTTP interceptor function that conditionally adds
+ * the current language as an HTTP header based on the request URL.
+ *
+ * @example
+ * ```ts
+ * // Use in HTTP client module setup
+ * import { HttpClientModule } from '@angular/common/http';
+ * import { httpLanguageHeaderInterceptor, HTTP_LANGUAGE_HEADER } from '@odx/angular/localization';
+ *
+ * @NgModule({
+ *   imports: [HttpClientModule],
+ *   providers: [
+ *     provideHttpClient(withInterceptors([
+ *       httpLanguageHeaderInterceptor({ allowedUrls: ['/api'], headerName: HTTP_LANGUAGE_HEADER })
+ *     ]))
+ *   ]
+ * })
+ * export class AppModule {}
+ * ```
+ */
 export function httpLanguageHeaderInterceptor({ allowedUrls, headerName }) {
     return (req, next) => {
         const language$ = inject(LocalizationService).activeLanguage$.pipe(take(1));
@@ -16,8 +43,34 @@ export function httpLanguageHeaderInterceptor({ allowedUrls, headerName }) {
         return next(req);
     };
 }
+/**
+ * Provides a localization feature that automatically adds a language header to HTTP requests
+ * for specified URLs, using the current active language. This function simplifies setting up
+ * the HTTP language header interceptor by wrapping it into a LocalizationFeature, making it easy
+ * to integrate with the application's localization infrastructure.
+ *
+ * @param {HttpLanguageHeaderInterceptorConfig} config - The configuration for the language header
+ * interceptor, specifying which URLs should include the language header and optionally defining a
+ * custom header name.
+ * @returns {LocalizationFeature} A localization feature object that can be used to configure
+ * the application's localization settings to include automatic language header addition for HTTP requests.
+ *
+ * @example
+ * ```ts
+ * // Example usage with the localization provider
+ * import { provideLocalization, LocalizationModule, withHttpLanguageHeader } from '@odx/angular/localization';
+ *
+ * @NgModule({
+ *   imports: [LocalizationModule],
+ *   providers: [
+ *     provideLocalization({}, withHttpLanguageHeader({ allowedUrls: ['/api'] }))
+ *   ]
+ * })
+ * export class AppModule {}
+ * ```
+ */
 export function withHttpLanguageHeader(config) {
     const providers = provideHttpClient(withInterceptors([httpLanguageHeaderInterceptor(config)]));
     return makeLocalizationFeature(providers);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/localization/lib/features/with-http-language-query-param.mjs

@@ -5,6 +5,32 @@ import { switchMap, take } from 'rxjs';
 import { LocalizationService } from '../localization.service';
 import { makeLocalizationFeature } from '../models';
 export const HTTP_LANGUAGE_QUERY = 'language';
+/**
+ * Creates an HTTP interceptor function that appends the current language as a query parameter
+ * to outgoing HTTP requests that match specified URLs. This interceptor enables dynamic content
+ * localization by informing the backend of the user's preferred language.
+ *
+ * @param {HttpLanguageQueryParamInterceptorConfig} config - Configuration for the interceptor,
+ * including allowed URLs and an optional custom name for the query parameter.
+ * @returns {HttpInterceptorFn} The interceptor function ready to be applied to the HTTP client.
+ *
+ * @example
+ * ```ts
+ * // Applying the interceptor in an Angular module
+ * import { HttpClientModule } from '@angular/common/http';
+ * import { withHttpLanguageQueryParam } from '@odx/angular/localization';
+ *
+ * @NgModule({
+ *   imports: [HttpClientModule],
+ *   providers: [
+ *     provideHttpClient(withInterceptors([
+ *       withHttpLanguageQueryParam({ allowedUrls: ['/api/resources'] })
+ *     ]))
+ *   ]
+ * })
+ * export class ApiModule {}
+ * ```
+ */
 export function withHttpLanguageQueryParamInterceptor({ allowedUrls, queryParamName }) {
     return (req, next) => {
         const language$ = inject(LocalizationService).activeLanguage$.pipe(take(1));
@@ -16,8 +42,33 @@ export function withHttpLanguageQueryParamInterceptor({ allowedUrls, queryParamN
         return next(req);
     };
 }
+/**
+ * Registers the HTTP interceptor that appends the current language as a query parameter to
+ * outgoing requests for configured URLs as a localization feature. This utility function
+ * simplifies the setup by bundling the interceptor into a feature that can be easily integrated
+ * with localization configurations.
+ *
+ * @param {HttpLanguageQueryParamInterceptorConfig} config - Configuration for appending the
+ * language query parameter, including allowed URLs and an optional parameter name.
+ * @returns {LocalizationFeature} A localization feature encapsulating the interceptor, ready
+ * for integration with the application's localization setup.
+ *
+ * @example
+ * ```ts
+ * // Integrating the localization feature in an Angular module
+ * import { provideLocalization } from '@angular/core';
+ * import { withHttpLanguageQueryParam } from '@odx/angular/localization';
+ *
+ * @NgModule({
+ *   providers: [
+ *     provideLocalization({}, withHttpLanguageQueryParam({ allowedUrls: ['/api'] }))
+ *   ]
+ * })
+ * export class AppModule {}
+ * ```
+ */
 export function withHttpLanguageQueryParam(config) {
     const providers = provideHttpClient(withInterceptors([withHttpLanguageQueryParamInterceptor(config)]));
     return makeLocalizationFeature(providers);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l0aC1odHRwLWxhbmd1YWdlLXF1ZXJ5LXBhcmFtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2xvY2FsaXphdGlvbi9zcmMvbGliL2ZlYXR1cmVzL3dpdGgtaHR0cC1sYW5ndWFnZS1xdWVyeS1wYXJhbS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXFCLGlCQUFpQixFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDOUYsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDOUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDdkMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDOUQsT0FBTyxFQUF1Qix1QkFBdUIsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUV6RSxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxVQUFVLENBQUM7QUFPOUMsTUFBTSxVQUFVLHFDQUFxQyxDQUFDLEVBQUUsV0FBVyxFQUFFLGNBQWMsRUFBMkM7SUFDNUgsT0FBTyxDQUFDLEdBQUcsRUFBRSxJQUFJLEVBQUUsRUFBRTtRQUNuQixNQUFNLFNBQVMsR0FBRyxNQUFNLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzVFLEtBQUssTUFBTSxVQUFVLElBQUksV0FBVyxFQUFFO1lBQ3BDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxVQUFVLENBQUM7Z0JBQUUsU0FBUztZQUM3QyxPQUFPLFNBQVMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLFNBQVMsRUFBRSxFQUFFLENBQUMsY0FBYyxJQUFJLG1CQUFtQixDQUFDLEVBQUUsUUFBUSxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1NBQ3ZJO1FBQ0QsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbkIsQ0FBQyxDQUFDO0FBQ0osQ0FBQztBQUVELE1BQU0sVUFBVSwwQkFBMEIsQ0FBQyxNQUErQztJQUN4RixNQUFNLFNBQVMsR0FBRyxpQkFBaUIsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLHFDQUFxQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXZHLE9BQU8sdUJBQXVCLENBQUMsU0FBUyxDQUFDLENBQUM7QUFDNUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEh0dHBJbnRlcmNlcHRvckZuLCBwcm92aWRlSHR0cENsaWVudCwgd2l0aEludGVyY2VwdG9ycyB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgbWF0Y2hVcmwgfSBmcm9tICdAb2R4L2FuZ3VsYXIvdXRpbHMnO1xuaW1wb3J0IHsgc3dpdGNoTWFwLCB0YWtlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBMb2NhbGl6YXRpb25TZXJ2aWNlIH0gZnJvbSAnLi4vbG9jYWxpemF0aW9uLnNlcnZpY2UnO1xuaW1wb3J0IHsgTG9jYWxpemF0aW9uRmVhdHVyZSwgbWFrZUxvY2FsaXphdGlvbkZlYXR1cmUgfSBmcm9tICcuLi9tb2RlbHMnO1xuXG5leHBvcnQgY29uc3QgSFRUUF9MQU5HVUFHRV9RVUVSWSA9ICdsYW5ndWFnZSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgSHR0cExhbmd1YWdlUXVlcnlQYXJhbUludGVyY2VwdG9yQ29uZmlnIHtcbiAgYWxsb3dlZFVybHM6IEFycmF5PHN0cmluZyB8IFJlZ0V4cD47XG4gIHF1ZXJ5UGFyYW1OYW1lPzogc3RyaW5nO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gd2l0aEh0dHBMYW5ndWFnZVF1ZXJ5UGFyYW1JbnRlcmNlcHRvcih7IGFsbG93ZWRVcmxzLCBxdWVyeVBhcmFtTmFtZSB9OiBIdHRwTGFuZ3VhZ2VRdWVyeVBhcmFtSW50ZXJjZXB0b3JDb25maWcpOiBIdHRwSW50ZXJjZXB0b3JGbiB7XG4gIHJldHVybiAocmVxLCBuZXh0KSA9PiB7XG4gICAgY29uc3QgbGFuZ3VhZ2UkID0gaW5qZWN0KExvY2FsaXphdGlvblNlcnZpY2UpLmFjdGl2ZUxhbmd1YWdlJC5waXBlKHRha2UoMSkpO1xuICAgIGZvciAoY29uc3QgYWxsb3dlZFVybCBvZiBhbGxvd2VkVXJscykge1xuICAgICAgaWYgKCFtYXRjaFVybChyZXEudXJsLCBhbGxvd2VkVXJsKSkgY29udGludWU7XG4gICAgICByZXR1cm4gbGFuZ3VhZ2UkLnBpcGUoc3dpdGNoTWFwKChsYW5ndWFnZSkgPT4gbmV4dChyZXEuY2xvbmUoeyBzZXRQYXJhbXM6IHsgW3F1ZXJ5UGFyYW1OYW1lID8/IEhUVFBfTEFOR1VBR0VfUVVFUlldOiBsYW5ndWFnZSB9IH0pKSkpO1xuICAgIH1cbiAgICByZXR1cm4gbmV4dChyZXEpO1xuICB9O1xufVxuXG5leHBvcnQgZnVuY3Rpb24gd2l0aEh0dHBMYW5ndWFnZVF1ZXJ5UGFyYW0oY29uZmlnOiBIdHRwTGFuZ3VhZ2VRdWVyeVBhcmFtSW50ZXJjZXB0b3JDb25maWcpOiBMb2NhbGl6YXRpb25GZWF0dXJlIHtcbiAgY29uc3QgcHJvdmlkZXJzID0gcHJvdmlkZUh0dHBDbGllbnQod2l0aEludGVyY2VwdG9ycyhbd2l0aEh0dHBMYW5ndWFnZVF1ZXJ5UGFyYW1JbnRlcmNlcHRvcihjb25maWcpXSkpO1xuXG4gIHJldHVybiBtYWtlTG9jYWxpemF0aW9uRmVhdHVyZShwcm92aWRlcnMpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/localization/lib/loaders/browser-language-loader.mjs

@@ -1,6 +1,38 @@
 import { inject } from '@angular/core';
 import { WindowRef } from '@odx/angular';
+/**
+ * Asynchronously loads the browser's current language setting by utilizing the `WindowRef` service.
+ * This function is intended to be used as a dynamic language loader within a localization configuration,
+ * allowing applications to automatically adapt to the user's preferred language as specified in their
+ * browser settings.
+ *
+ * The `WindowRef` service abstracts window-related operations, making it easier to interact with global
+ * browser properties and methods in a testable and platform-agnostic way. This function makes use of
+ * `WindowRef` to access the navigator's language setting in a safe and Angular-friendly manner.
+ *
+ * @returns {Promise<string>} A promise that resolves to the language code (e.g., 'en', 'fr') of the
+ * browser's currently configured language. This can then be used to set the active language in a
+ * localization configuration.
+ *
+ * @example
+ * ```ts
+ * // Example usage in a localization configuration
+ * import { provideLocalization } from '@odx/angular/utils';
+ * import { browserLanguageLoader } from '@odx/angular/localization';
+ *
+ * @NgModule({
+ *   providers: [
+ *     provideLocalization({
+ *       activeLanguageLoader: browserLanguageLoader,
+ *       availableLanguages: ['en', 'es', 'fr'],
+ *       availableLocales: ['en-US', 'es-ES', 'fr-FR']
+ *     })
+ *   ]
+ * })
+ * export class AppModule { }
+ * ```
+ */
 export const browserLanguageLoader = async () => {
     return inject(WindowRef).getLanguage();
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3Nlci1sYW5ndWFnZS1sb2FkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvbG9jYWxpemF0aW9uL3NyYy9saWIvbG9hZGVycy9icm93c2VyLWxhbmd1YWdlLWxvYWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFHekMsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQXFCLEtBQUssSUFBSSxFQUFFO0lBQ2hFLE9BQU8sTUFBTSxDQUFDLFNBQVMsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDO0FBQ3pDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgV2luZG93UmVmIH0gZnJvbSAnQG9keC9hbmd1bGFyJztcbmltcG9ydCB7IExhbmd1YWdlTG9hZGVyRm4gfSBmcm9tICcuLi9tb2RlbHMnO1xuXG5leHBvcnQgY29uc3QgYnJvd3Nlckxhbmd1YWdlTG9hZGVyOiBMYW5ndWFnZUxvYWRlckZuID0gYXN5bmMgKCkgPT4ge1xuICByZXR1cm4gaW5qZWN0KFdpbmRvd1JlZikuZ2V0TGFuZ3VhZ2UoKTtcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/localization/lib/localization.config.mjs

@@ -2,9 +2,79 @@ import { APP_INITIALIZER, makeEnvironmentProviders } from '@angular/core';
 import { createConfigTokens } from '@odx/angular/utils';
 import { LocalizationService } from './localization.service';
 export const DEFAULT_AVAILABLE_LANGUAGES = ['en-US', 'en-GB', 'en', 'de-DE', 'de', 'es-ES', 'es', 'fr-FR', 'fr-CA', 'fr'];
+/**
+ * Utilizes `createConfigTokens` to generate configuration tokens and related utilities for the
+ * localization settings within the application. It defines a structured and type-safe approach
+ * for managing localization configurations, such as available languages, and potentially
+ * a dynamic loader for the active language. The generated tokens and utilities facilitate accessing
+ * and providing these configurations throughout the application.
+ *
+ * @const {InjectionToken<LocalizationConfig>} LocalizationConfig - An InjectionToken for accessing
+ * the localization configuration within Angular's dependency injection framework. Use this token to inject
+ * localization configurations into services, components, or other tokens.
+ *
+ * @const {LocalizationConfig} LocalizationDefaultConfig - The default configuration values for localization,
+ * based on the provided settings. Includes the default available languages.
+ *
+ * @const {Function} injectLocalizationConfig - A utility function that returns the injected value of
+ * `LocalizationConfig` token. Use this function to access the current localization configuration in
+ * a type-safe manner.
+ *
+ * @const {Function} provideLocalizationConfig - A utility function to provide the `LocalizationConfig` token
+ * with specific values. Use this function to configure and override default localization settings within
+ * an Angular module or component.
+ *
+ * @example
+ * ```ts
+ * // Providing localization settings in an Angular module
+ * @NgModule({
+ *   providers: [
+ *     provideLocalizationConfig({
+ *       availableLanguages: ['en', 'es', 'fr'],
+ *     })
+ *   ]
+ * })
+ * export class AppModule { }
+ *
+ * // Injecting and using the localization configuration in a service
+ * @Injectable({ providedIn: 'root' })
+ * export class MyLocalizationService {
+ *   constructor(@Inject(LocalizationConfig) private config: LocalizationConfig) {
+ *     console.log('Available languages:', config.availableLanguages);
+ *   }
+ * }
+ * ```
+ */
 export const { LocalizationConfig, LocalizationDefaultConfig, injectLocalizationConfig, provideLocalizationConfig } = createConfigTokens('Localization', '@odx/angular/internal/translate', {
     availableLanguages: DEFAULT_AVAILABLE_LANGUAGES,
 });
+/**
+ * Sets up the localization configuration for the application and initializes the localization
+ * system with the provided configuration and features. This function is typically called
+ * within the main module or a core module of the application to ensure localization settings
+ * are available and active as early as possible.
+ *
+ * @param {Partial<LocalizationConfig>} config The localization configuration settings, including
+ * available languages and optionally, a custom loader for the active language.
+ * @param {...LocalizationFeature[]} features Additional localization features or configurations
+ * to be registered as part of the application's environment providers.
+ * @returns {EnvironmentProviders} A collection of providers for setting up the application's
+ * localization environment, to be used with Angular's environment-specific injector configuration.
+ * @example
+ * ```ts
+ * // Example of providing localization settings in an Angular module
+ * @NgModule({
+ *   imports: [...],
+ *   providers: [
+ *     provideLocalization({
+ *       availableLanguages: ['en', 'es', 'fr'],
+ *       activeLanguageLoader: () => fetch('/api/user/language').then(res => res.text()),
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
 export function provideLocalization(config, ...features) {
     return makeEnvironmentProviders([
         provideLocalizationConfig(config),
@@ -17,4 +87,4 @@ export function provideLocalization(config, ...features) {
         features,
     ]);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localization.config.js","sourceRoot":"","sources":["../../../../../../libs/angular/localization/src/lib/localization.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAwB,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAChG,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAG7D,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;AAkB1H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,CAAC,MAAM,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,GAAG,kBAAkB,CACtI,cAAc,EACd,iCAAiC,EACjC;IACE,kBAAkB,EAAE,2BAA2B;CAC1B,CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAmC,EAAE,GAAG,QAA+B;IACzG,OAAO,wBAAwB,CAAC;QAC9B,yBAAyB,CAAC,MAAM,CAAC;QACjC;YACE,OAAO,EAAE,eAAe;YACxB,UAAU,EAAE,CAAC,mBAAwC,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,mBAAmB,CAAC,kBAAkB,EAAE;YACxG,IAAI,EAAE,CAAC,mBAAmB,CAAC;YAC3B,KAAK,EAAE,IAAI;SACZ;QACD,QAAQ;KACT,CAAC,CAAC;AACL,CAAC","sourcesContent":["import { APP_INITIALIZER, EnvironmentProviders, makeEnvironmentProviders } from '@angular/core';\nimport { createConfigTokens } from '@odx/angular/utils';\nimport { LocalizationService } from './localization.service';\nimport { LanguageLoaderFn, LocalizationFeature } from './models';\n\nexport const DEFAULT_AVAILABLE_LANGUAGES = ['en-US', 'en-GB', 'en', 'de-DE', 'de', 'es-ES', 'es', 'fr-FR', 'fr-CA', 'fr'];\n\n/**\n * Defines the structure for the localization configuration used throughout the application.\n * It allows specifying available languages, and includes an optional loader\n * function for dynamically determining the active language.\n *\n * @property {LanguageLoaderFn} [activeLanguageLoader] Optional function for loading the\n * active language dynamically, useful for scenarios where the application's language\n * needs to be determined based on user settings, browser settings, or external data.\n * @property {string[]} availableLanguages An array of language codes representing the\n * languages available in the application.\n */\nexport interface LocalizationConfig {\n  activeLanguageLoader?: LanguageLoaderFn;\n  availableLanguages: string[];\n}\n\n/**\n * Utilizes `createConfigTokens` to generate configuration tokens and related utilities for the\n * localization settings within the application. It defines a structured and type-safe approach\n * for managing localization configurations, such as available languages, and potentially\n * a dynamic loader for the active language. The generated tokens and utilities facilitate accessing\n * and providing these configurations throughout the application.\n *\n * @const {InjectionToken<LocalizationConfig>} LocalizationConfig - An InjectionToken for accessing\n * the localization configuration within Angular's dependency injection framework. Use this token to inject\n * localization configurations into services, components, or other tokens.\n *\n * @const {LocalizationConfig} LocalizationDefaultConfig - The default configuration values for localization,\n * based on the provided settings. Includes the default available languages.\n *\n * @const {Function} injectLocalizationConfig - A utility function that returns the injected value of\n * `LocalizationConfig` token. Use this function to access the current localization configuration in\n * a type-safe manner.\n *\n * @const {Function} provideLocalizationConfig - A utility function to provide the `LocalizationConfig` token\n * with specific values. Use this function to configure and override default localization settings within\n * an Angular module or component.\n *\n * @example\n * ```ts\n * // Providing localization settings in an Angular module\n * @NgModule({\n *   providers: [\n *     provideLocalizationConfig({\n *       availableLanguages: ['en', 'es', 'fr'],\n *     })\n *   ]\n * })\n * export class AppModule { }\n *\n * // Injecting and using the localization configuration in a service\n * @Injectable({ providedIn: 'root' })\n * export class MyLocalizationService {\n *   constructor(@Inject(LocalizationConfig) private config: LocalizationConfig) {\n *     console.log('Available languages:', config.availableLanguages);\n *   }\n * }\n * ```\n */\nexport const { LocalizationConfig, LocalizationDefaultConfig, injectLocalizationConfig, provideLocalizationConfig } = createConfigTokens(\n  'Localization',\n  '@odx/angular/internal/translate',\n  {\n    availableLanguages: DEFAULT_AVAILABLE_LANGUAGES,\n  } as LocalizationConfig,\n);\n\n/**\n * Sets up the localization configuration for the application and initializes the localization\n * system with the provided configuration and features. This function is typically called\n * within the main module or a core module of the application to ensure localization settings\n * are available and active as early as possible.\n *\n * @param {Partial<LocalizationConfig>} config The localization configuration settings, including\n * available languages and optionally, a custom loader for the active language.\n * @param {...LocalizationFeature[]} features Additional localization features or configurations\n * to be registered as part of the application's environment providers.\n * @returns {EnvironmentProviders} A collection of providers for setting up the application's\n * localization environment, to be used with Angular's environment-specific injector configuration.\n * @example\n * ```ts\n * // Example of providing localization settings in an Angular module\n * @NgModule({\n *   imports: [...],\n *   providers: [\n *     provideLocalization({\n *       availableLanguages: ['en', 'es', 'fr'],\n *       activeLanguageLoader: () => fetch('/api/user/language').then(res => res.text()),\n *     }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n */\nexport function provideLocalization(config: Partial<LocalizationConfig>, ...features: LocalizationFeature[]): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    provideLocalizationConfig(config),\n    {\n      provide: APP_INITIALIZER,\n      useFactory: (localizationService: LocalizationService) => () => localizationService.loadActiveLanguage(),\n      deps: [LocalizationService],\n      multi: true,\n    },\n    features,\n  ]);\n}\n"]}