@odx/angular 5.7.4 → 6.0.1

package/esm2022/theming/lib/helpers/resolve-theme.mjs

@@ -1,5 +1,30 @@
 import { availableThemes } from '../models';
+/**
+ * Resolves the specified theme by checking if it exists in the predefined list of available themes.
+ * This function ensures that only valid themes are used in the application, providing a safeguard
+ * against invalid theme names and facilitating the dynamic application of themes.
+ *
+ * @param {string | null} [theme] - The name of the theme to resolve. It's optional and can be `null`.
+ * @returns {Theme | null} - Returns the resolved `Theme` object if the theme is found within the list of `availableThemes`;
+ * otherwise, returns `null` to indicate the theme is not recognized or available.
+ *
+ * @example
+ * ```ts
+ * // Assuming 'dark' and 'light' are in the availableThemes array
+ * console.log(resolveTheme('dark')); // Outputs the 'dark' Theme object
+ * console.log(resolveTheme('unknown')); // Outputs null
+ *
+ * // Using resolveTheme to apply a user-selected theme
+ * const userSelectedTheme = getUserSelectedTheme(); // This function gets the user's theme choice
+ * const themeToApply = resolveTheme(userSelectedTheme);
+ * if (themeToApply) {
+ *   applyTheme(themeToApply); // This function applies the resolved theme to the application
+ * } else {
+ *   console.warn('Selected theme is not available.');
+ * }
+ * ```
+ */
 export function resolveTheme(theme) {
     return availableThemes.find((t) => t === theme) ?? null;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZS10aGVtZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci90aGVtaW5nL3NyYy9saWIvaGVscGVycy9yZXNvbHZlLXRoZW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQVMsTUFBTSxXQUFXLENBQUM7QUFFbkQsTUFBTSxVQUFVLFlBQVksQ0FBQyxLQUFxQjtJQUNoRCxPQUFPLGVBQWUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsS0FBSyxLQUFLLENBQUMsSUFBSSxJQUFJLENBQUM7QUFDMUQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGF2YWlsYWJsZVRoZW1lcywgVGhlbWUgfSBmcm9tICcuLi9tb2RlbHMnO1xuXG5leHBvcnQgZnVuY3Rpb24gcmVzb2x2ZVRoZW1lKHRoZW1lPzogc3RyaW5nIHwgbnVsbCk6IFRoZW1lIHwgbnVsbCB7XG4gIHJldHVybiBhdmFpbGFibGVUaGVtZXMuZmluZCgodCkgPT4gdCA9PT0gdGhlbWUpID8/IG51bGw7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/theming/lib/helpers/theme-storage.mjs

@@ -1,5 +1,26 @@
 import { resolveTheme } from './resolve-theme';
+/**
+ * The key used to store the selected theme in `Storage`.
+ * This constant ensures consistent access to the theme setting across the application.
+ */
 export const THEME_STORAGE_NAME = '@odx/angular/theming:SelectedTheme';
+/**
+ * Saves the specified theme to storage. This function abstracts the storage interaction,
+ * providing a fail-safe mechanism to avoid exceptions if the storage is not available.
+ *
+ * @param {Storage | null | undefined} storage - The storage mechanism to use, typically `localStorage` or `sessionStorage`.
+ * @param {Theme} theme - The theme to save. Should be a value that is recognized by the application's theming system.
+ * @throws Will silently catch and ignore any exceptions caused by storage limitations or permissions.
+ *
+ * @example
+ * ```ts
+ * // Example usage with localStorage
+ * saveTheme(localStorage, 'dark');
+ *
+ * // Using sessionStorage instead
+ * saveTheme(sessionStorage, 'light');
+ * ```
+ */
 export function saveTheme(storage, theme) {
     try {
         storage?.setItem(THEME_STORAGE_NAME, theme);
@@ -8,6 +29,27 @@ export function saveTheme(storage, theme) {
         //
     }
 }
+/**
+ * Reads the theme from storage, attempting to resolve it to a valid application theme.
+ * If the theme cannot be found or is invalid, `null` is returned. This function also provides
+ * error handling for any storage access issues, ensuring the application can gracefully handle
+ * scenarios where storage is not available or accessible.
+ *
+ * @param {Storage | null} [storage] - The storage mechanism to use, typically `localStorage` or `sessionStorage`.
+ * @returns {Theme | null} - The resolved theme if found and valid; otherwise, `null`.
+ * @throws Will silently catch and ignore any exceptions caused by storage access, returning `null`.
+ *
+ * @example
+ * ```ts
+ * // Reading theme from localStorage
+ * const theme = readTheme(localStorage);
+ * if (theme) {
+ *   applyTheme(theme); // Assuming applyTheme is a function to apply the theme
+ * } else {
+ *   console.warn('No saved theme found or theme is invalid.');
+ * }
+ * ```
+ */
 export function readTheme(storage) {
     try {
         return resolveTheme(storage?.getItem(THEME_STORAGE_NAME)) ?? null;
@@ -16,4 +58,4 @@ export function readTheme(storage) {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUtc3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci90aGVtaW5nL3NyYy9saWIvaGVscGVycy90aGVtZS1zdG9yYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxvQ0FBb0MsQ0FBQztBQUV2RSxNQUFNLFVBQVUsU0FBUyxDQUFDLE9BQW1DLEVBQUUsS0FBWTtJQUN6RSxJQUFJO1FBQ0YsT0FBTyxFQUFFLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxLQUFLLENBQUMsQ0FBQztLQUM3QztJQUFDLE1BQU07UUFDTixFQUFFO0tBQ0g7QUFDSCxDQUFDO0FBRUQsTUFBTSxVQUFVLFNBQVMsQ0FBQyxPQUF3QjtJQUNoRCxJQUFJO1FBQ0YsT0FBTyxZQUFZLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDO0tBQ25FO0lBQUMsTUFBTTtRQUNOLE9BQU8sSUFBSSxDQUFDO0tBQ2I7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGhlbWUgfSBmcm9tICcuLi9tb2RlbHMnO1xuaW1wb3J0IHsgcmVzb2x2ZVRoZW1lIH0gZnJvbSAnLi9yZXNvbHZlLXRoZW1lJztcblxuZXhwb3J0IGNvbnN0IFRIRU1FX1NUT1JBR0VfTkFNRSA9ICdAb2R4L2FuZ3VsYXIvdGhlbWluZzpTZWxlY3RlZFRoZW1lJztcblxuZXhwb3J0IGZ1bmN0aW9uIHNhdmVUaGVtZShzdG9yYWdlOiBTdG9yYWdlIHwgbnVsbCB8IHVuZGVmaW5lZCwgdGhlbWU6IFRoZW1lKTogdm9pZCB7XG4gIHRyeSB7XG4gICAgc3RvcmFnZT8uc2V0SXRlbShUSEVNRV9TVE9SQUdFX05BTUUsIHRoZW1lKTtcbiAgfSBjYXRjaCB7XG4gICAgLy9cbiAgfVxufVxuXG5leHBvcnQgZnVuY3Rpb24gcmVhZFRoZW1lKHN0b3JhZ2U/OiBTdG9yYWdlIHwgbnVsbCk6IFRoZW1lIHwgbnVsbCB7XG4gIHRyeSB7XG4gICAgcmV0dXJuIHJlc29sdmVUaGVtZShzdG9yYWdlPy5nZXRJdGVtKFRIRU1FX1NUT1JBR0VfTkFNRSkpID8/IG51bGw7XG4gIH0gY2F0Y2gge1xuICAgIHJldHVybiBudWxsO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/theming/lib/theming.config.mjs

@@ -2,11 +2,44 @@ import { ENVIRONMENT_INITIALIZER, inject, makeEnvironmentProviders } from '@angu
 import { createConfigTokens } from '@odx/angular/utils';
 import { Theme } from './models';
 import { ThemingService } from './theming.service';
+/**
+ * Utility created by `createConfigTokens` for managing theming configuration tokens and functions.
+ * Provides easy access to theming configuration, default values, and dependency injection utilities.
+ */
 export const { ThemingConfig, injectThemingConfig, provideThemingConfig } = createConfigTokens('Theming', '@odx/angular/theme', {
     autoDetect: false,
     defaultTheme: Theme.LIGHT,
     storage: null,
 });
+/**
+ * Provides the theming configuration to the application and initializes the `ThemingService`
+ * based on the provided configuration. This function simplifies the setup of a dynamic theming
+ * system, integrating with Angular's environment initializers to ensure proper initialization.
+ *
+ * @template D - The dependencies required by the theming configuration, if any.
+ * @param {ConfigProvider<Partial<ThemingConfig>, D>} config - The theming configuration or a configuration factory provider.
+ * @returns {EnvironmentProviders} An array of providers for setting up theming in the application.
+ *
+ * @example
+ * ```ts
+ * // Providing a simple theming configuration
+ * provideTheming({
+ *   autoDetect: true,
+ *   defaultTheme: Theme.DARK,
+ *   storage: localStorage,
+ * });
+ *
+ * // Providing a theming configuration with dependencies
+ * provideTheming({
+ *   useFactory: (deps: Dependencies) => ({
+ *     autoDetect: deps.setting,
+ *     defaultTheme: Theme.DARK,
+ *     storage: localStorage,
+ *   }),
+ *   deps: [SomeDependency],
+ * });
+ * ```
+ */
 export function provideTheming(config) {
     return makeEnvironmentProviders([
         provideThemingConfig(config),
@@ -18,4 +51,4 @@ export function provideTheming(config) {
         },
     ]);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/theming/lib/theming.service.mjs

@@ -7,24 +7,49 @@ import { Theme } from './models';
 import { injectThemingConfig } from './theming.config';
 import * as i0 from "@angular/core";
 export const THEME_ATTRIBUTE_NAME = 'odxTheme';
+/**
+ * Manages theming for the application. It allows for dynamic theme selection, automatically saves theme preferences,
+ * and applies the user's preferred theme or the default theme based on configuration settings.
+ *
+ * The service leverages the BehaviorSubject pattern to reactively handle theme changes across the application,
+ * ensuring that subscribers are notified whenever the theme changes. It also interacts with the DOM directly
+ * to apply the current theme and with the provided storage mechanism to persist theme preferences.
+ */
 export class ThemingService {
     constructor() {
         this.config = injectThemingConfig();
         this.document = inject(DOCUMENT);
         this.windowRef = inject(WindowRef);
         this.theme$$ = new BehaviorSubject(this.getInitialTheme());
+        /**
+         * An observable stream of the current theme, emitting values whenever the theme changes.
+         * Subscribers to this observable can react to theme changes in real-time.
+         */
         this.theme$ = this.theme$$.pipe(distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
         this.theme$.subscribe((theme) => {
             this.document.body.setAttribute(THEME_ATTRIBUTE_NAME, theme);
             saveTheme(this.config.storage, theme);
         });
     }
+    /**
+     * Selects and applies a given theme by updating the BehaviorSubject and persisting the preference.
+     *
+     * @param {Theme} theme - The theme to apply.
+     */
     selectTheme(theme) {
         this.theme$$.next(theme);
     }
+    /**
+     * Retrieves the currently selected theme.
+     *
+     * @returns {Theme} The currently selected theme.
+     */
     getSelectedTheme() {
         return this.theme$$.getValue();
     }
+    /**
+     * Toggles between dark and light themes, depending on the current theme.
+     */
     toggleDarkMode() {
         const currentTheme = this.getSelectedTheme();
         if (currentTheme === Theme.DARK) {
@@ -34,9 +59,15 @@ export class ThemingService {
             this.enableDarkMode();
         }
     }
+    /**
+     * Enables the dark mode theme.
+     */
     enableDarkMode() {
         this.selectTheme(Theme.DARK);
     }
+    /**
+     * Enables the light mode theme.
+     */
     enableLightMode() {
         this.selectTheme(Theme.LIGHT);
     }
@@ -54,4 +85,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/decorators/pure.mjs

@@ -1,3 +1,54 @@
+/**
+ * A decorator that transforms a class method or getter into a pure function. For methods, it caches the result
+ * of the first invocation with a given set of arguments and returns the cached result on subsequent invocations
+ * with the same arguments. For getters, it caches the result of the first access and returns the cached value
+ * on subsequent accesses.
+ *
+ * This decorator is intended to improve performance by avoiding unnecessary recalculations or processing
+ * when the inputs have not changed.
+ *
+ * @template T The type of the property being decorated.
+ * @param {object} _target The prototype of the class.
+ * @param {string} propertyKey The name of the method or getter.
+ * @param {TypedPropertyDescriptor<T>} descriptor The property descriptor for the method or getter.
+ * @throws {Error} Throws an error if applied to non-function properties.
+ * @returns {TypedPropertyDescriptor<T>} A new descriptor with the getter or method patched for pure behavior.
+ *
+ * @example
+ * Usage with a getter:
+ * ```ts
+ * class ExampleClass {
+ *   private _value: number = Math.random();
+ *
+ *   @Pure
+ *   get value(): number {
+ *     console.log('Getter called');
+ *     return this._value;
+ *   }
+ * }
+ *
+ * const example = new ExampleClass();
+ * console.log(example.value); // Logs 'Getter called' and the value
+ * console.log(example.value); // Logs only the value, without calling the getter again
+ * ```
+ *
+ * Usage with a method:
+ * ```ts
+ * class Counter {
+ *   private count = 0;
+ *
+ *   @Pure
+ *   increment(step: number) {
+ *     console.log('Increment called');
+ *     return (this.count += step);
+ *   }
+ * }
+ *
+ * const counter = new Counter();
+ * console.log(counter.increment(1)); // Logs 'Increment called' and 1
+ * console.log(counter.increment(1)); // Logs 1 without calling increment again
+ * ```
+ */
 export function Pure(_target, propertyKey, { get, enumerable, value }) {
     if (get) {
         return {
@@ -34,4 +85,4 @@ export function Pure(_target, propertyKey, { get, enumerable, value }) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/angular.mjs

@@ -6,12 +6,28 @@ function reactiveBinding(updateFn) {
     const takeUntilDestroyed = untilDestroyed();
     return (source$) => source$.pipe(tap((state) => updateFn(state)), takeUntilDestroyed());
 }
+/**
+ * Binds an observable to toggle a CSS class on the host element based on the truthiness of the emitted values.
+ * The subscription automatically ends when the component is destroyed.
+ *
+ * @template T The type of items emitted by the source observable.
+ * @param {Observable<T> | null | undefined} source$ The observable source emitting truthy or falsy values.
+ * @param {string} cssClass The CSS class to toggle based on the emitted values.
+ */
 export function reactiveClassBinding(source$, cssClass) {
     const { nativeElement } = injectElement();
     if (source$) {
         source$.pipe(reactiveBinding((state) => nativeElement.classList.toggle(cssClass, !!state))).subscribe();
     }
 }
+/**
+ * Binds an observable to update attributes on the host element with the emitted values.
+ * The subscription automatically ends when the component is destroyed.
+ *
+ * @template T The type of items emitted by the source observable.
+ * @param {Observable<T> | null | undefined} source$ The observable source.
+ * @param {...string[]} attributes The attributes to set on the host element based on the emitted values.
+ */
 export function reactiveAttributeBinding(source$, ...attributes) {
     const { nativeElement } = injectElement();
     if (source$) {
@@ -24,13 +40,33 @@ export function reactiveAttributeBinding(source$, ...attributes) {
             .subscribe();
     }
 }
+/**
+ * Injects the ElementRef of the host element in an Angular component or directive.
+ *
+ * @template T The expected type of the native element.
+ * @returns {ElementRef<T>} The injected ElementRef instance.
+ */
 export function injectElement() {
     return inject(ElementRef);
 }
+/**
+ * Tracking function for use with `*ngFor` that tracks items by their index.
+ *
+ * @param {number} index The index of the item in the iterable.
+ * @returns {number} The index, used as the trackBy identity.
+ */
 export function trackByIndex(index) {
     return index;
 }
+/**
+ * Tracking function for use with `*ngFor` that tracks items by their unique ID.
+ *
+ * @template T The type of the items in the iterable, must have an 'id' property.
+ * @param {number} _ The index of the item in the iterable, not used.
+ * @param {T} item The item in the iterable.
+ * @returns {T['id']} The item's ID, used as the trackBy identity.
+ */
 export function trackById(_, { id }) {
     return id;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/array.mjs

@@ -8,8 +8,10 @@ import { isNumber, isString } from './type-guards';
  * @param {K} key - The key whose values are to be plucked from each object in the array.
  * @returns {Array<T[K]>} An array of values corresponding to the specified key from each object.
  * @example
+ * ```ts
  * const users = [{ name: 'Alice' }, { name: 'Bob' }];
  * const names = pluckFromArray(users, 'name'); // ['Alice', 'Bob']
+ * ```
  */
 export function pluckFromArray(arr, key) {
     return arr.map((value) => value[key]);
@@ -22,8 +24,10 @@ export function pluckFromArray(arr, key) {
  * @param {OrderByDirection} [direction='ASC'] - The direction to sort ('ASC' for ascending, 'DESC' for descending).
  * @returns {(a: T, b: T) => number} A compare function that can be used in the array sort method.
  * @example
+ * ```ts
  * const items = [{ value: 10 }, { value: 5 }, { value: 7 }];
  * const sortedItems = items.sort(orderBy('value', 'ASC')); // Sorted by value in ascending order
+ * ```
  */
 export function orderBy(key, direction = 'ASC') {
     return (a, b) => {
@@ -44,4 +48,4 @@ export function orderBy(key, direction = 'ASC') {
         return 0;
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/build-url.mjs

@@ -1,4 +1,24 @@
+/**
+ * Constructs a URL string from provided segments, ensuring proper slash separation without duplications.
+ * It gracefully handles `null`, `undefined`, and symbol values by omitting them from the final URL.
+ * Additionally, the function preserves the protocol part of the URL, if specified.
+ *
+ * @param {...Array<string | number | symbol | null | undefined>} args - The segments to concatenate into a URL.
+ * Can be a mix of strings, numbers, symbols (converted to strings), or `null`/`undefined` (which are omitted).
+ * @returns {string} The constructed URL string with correctly formatted slashes.
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * console.log(buildUrl('http://example.com', 'path', 'to', 'resource'));
+ * // Outputs: "http://example.com/path/to/resource"
+ *
+ * // Removing duplicate slashes
+ * console.log(buildUrl('http://example.com/', '/path/', '//to', '/resource/'));
+ * // Outputs: "http://example.com/path/to/resource/"
+ * ```
+ */
 export function buildUrl(...args) {
     return args.join('/').replace(/(^.*)(https?:\/\/)|(\/)+/g, '$2$3');
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQtdXJsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3V0aWxzL3NyYy9saWIvaGVscGVycy9idWlsZC11cmwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLFFBQVEsQ0FBQyxHQUFHLElBQXdEO0lBQ2xGLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMsMkJBQTJCLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFDckUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBidWlsZFVybCguLi5hcmdzOiBBcnJheTxzdHJpbmcgfCBudW1iZXIgfCBzeW1ib2wgfCBudWxsIHwgdW5kZWZpbmVkPik6IHN0cmluZyB7XG4gIHJldHVybiBhcmdzLmpvaW4oJy8nKS5yZXBsYWNlKC8oXi4qKShodHRwcz86XFwvXFwvKXwoXFwvKSsvZywgJyQyJDMnKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQtdXJsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3V0aWxzL3NyYy9saWIvaGVscGVycy9idWlsZC11cmwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FtQkc7QUFDSCxNQUFNLFVBQVUsUUFBUSxDQUFDLEdBQUcsSUFBd0Q7SUFDbEYsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQywyQkFBMkIsRUFBRSxNQUFNLENBQUMsQ0FBQztBQUNyRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb25zdHJ1Y3RzIGEgVVJMIHN0cmluZyBmcm9tIHByb3ZpZGVkIHNlZ21lbnRzLCBlbnN1cmluZyBwcm9wZXIgc2xhc2ggc2VwYXJhdGlvbiB3aXRob3V0IGR1cGxpY2F0aW9ucy5cbiAqIEl0IGdyYWNlZnVsbHkgaGFuZGxlcyBgbnVsbGAsIGB1bmRlZmluZWRgLCBhbmQgc3ltYm9sIHZhbHVlcyBieSBvbWl0dGluZyB0aGVtIGZyb20gdGhlIGZpbmFsIFVSTC5cbiAqIEFkZGl0aW9uYWxseSwgdGhlIGZ1bmN0aW9uIHByZXNlcnZlcyB0aGUgcHJvdG9jb2wgcGFydCBvZiB0aGUgVVJMLCBpZiBzcGVjaWZpZWQuXG4gKlxuICogQHBhcmFtIHsuLi5BcnJheTxzdHJpbmcgfCBudW1iZXIgfCBzeW1ib2wgfCBudWxsIHwgdW5kZWZpbmVkPn0gYXJncyAtIFRoZSBzZWdtZW50cyB0byBjb25jYXRlbmF0ZSBpbnRvIGEgVVJMLlxuICogQ2FuIGJlIGEgbWl4IG9mIHN0cmluZ3MsIG51bWJlcnMsIHN5bWJvbHMgKGNvbnZlcnRlZCB0byBzdHJpbmdzKSwgb3IgYG51bGxgL2B1bmRlZmluZWRgICh3aGljaCBhcmUgb21pdHRlZCkuXG4gKiBAcmV0dXJucyB7c3RyaW5nfSBUaGUgY29uc3RydWN0ZWQgVVJMIHN0cmluZyB3aXRoIGNvcnJlY3RseSBmb3JtYXR0ZWQgc2xhc2hlcy5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIC8vIEJhc2ljIHVzYWdlXG4gKiBjb25zb2xlLmxvZyhidWlsZFVybCgnaHR0cDovL2V4YW1wbGUuY29tJywgJ3BhdGgnLCAndG8nLCAncmVzb3VyY2UnKSk7XG4gKiAvLyBPdXRwdXRzOiBcImh0dHA6Ly9leGFtcGxlLmNvbS9wYXRoL3RvL3Jlc291cmNlXCJcbiAqXG4gKiAvLyBSZW1vdmluZyBkdXBsaWNhdGUgc2xhc2hlc1xuICogY29uc29sZS5sb2coYnVpbGRVcmwoJ2h0dHA6Ly9leGFtcGxlLmNvbS8nLCAnL3BhdGgvJywgJy8vdG8nLCAnL3Jlc291cmNlLycpKTtcbiAqIC8vIE91dHB1dHM6IFwiaHR0cDovL2V4YW1wbGUuY29tL3BhdGgvdG8vcmVzb3VyY2UvXCJcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRVcmwoLi4uYXJnczogQXJyYXk8c3RyaW5nIHwgbnVtYmVyIHwgc3ltYm9sIHwgbnVsbCB8IHVuZGVmaW5lZD4pOiBzdHJpbmcge1xuICByZXR1cm4gYXJncy5qb2luKCcvJykucmVwbGFjZSgvKF4uKikoaHR0cHM/OlxcL1xcLyl8KFxcLykrL2csICckMiQzJyk7XG59XG4iXX0=

package/esm2022/utils/lib/helpers/build-website-url.mjs

@@ -16,14 +16,15 @@ export const DRAEGER_WEBSITE_URL = 'https://www.draeger.com';
  * @returns {string} The fully constructed URL, including the base URL and all provided path segments.
  *
  * @example
+ * ```ts
  * // Returns 'https://www.draeger.com/about-us'
  * const url = buildWebsiteUrl('about-us');
  *
- * @example
  * // Can also handle multiple segments, returning 'https://www.draeger.com/products/search/123'
  * const productUrl = buildWebsiteUrl('products', 'search', 123);
+ * ```
  */
 export function buildWebsiteUrl(...segments) {
     return buildUrl(DRAEGER_WEBSITE_URL, ...segments);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQtd2Vic2l0ZS11cmwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2J1aWxkLXdlYnNpdGUtdXJsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFdkM7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyx5QkFBeUIsQ0FBQztBQUU3RDs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FpQkc7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUFDLEdBQUcsUUFBNEQ7SUFDN0YsT0FBTyxRQUFRLENBQUMsbUJBQW1CLEVBQUUsR0FBRyxRQUFRLENBQUMsQ0FBQztBQUNwRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYnVpbGRVcmwgfSBmcm9tICcuL2J1aWxkLXVybCc7XG5cbi8qKlxuICogQSBjb25zdGFudCByZXByZXNlbnRpbmcgdGhlIGJhc2UgVVJMIGZvciB0aGUgRHJhZWdlciB3ZWJzaXRlLlxuICogQGNvbnN0YW50XG4gKiBAdHlwZSB7c3RyaW5nfVxuICogQGRlZmF1bHQgJ2h0dHBzOi8vd3d3LmRyYWVnZXIuY29tJ1xuICovXG5leHBvcnQgY29uc3QgRFJBRUdFUl9XRUJTSVRFX1VSTCA9ICdodHRwczovL3d3dy5kcmFlZ2VyLmNvbSc7XG5cbi8qKlxuICogQ29uc3RydWN0cyBhIGZ1bGwgVVJMIGZvciB0aGUgRHJhZWdlciB3ZWJzaXRlIGJ5IGFwcGVuZGluZyB0aGUgcHJvdmlkZWQgcGF0aCBzZWdtZW50cyB0byB0aGUgYmFzZSBVUkwuXG4gKiBUaGlzIGZ1bmN0aW9uIGlzIGEgdXRpbGl0eSBmb3IgY3JlYXRpbmcgZnVsbHkgcXVhbGlmaWVkIFVSTHMgdG8gdmFyaW91cyByZXNvdXJjZXMgb3IgcGFnZXMgd2l0aGluIHRoZSBEcmFlZ2VyIHdlYnNpdGUuXG4gKlxuICogQGZ1bmN0aW9uIGJ1aWxkV2Vic2l0ZVVybFxuICogQHBhcmFtIHsuLi4oc3RyaW5nIHwgbnVtYmVyIHwgc3ltYm9sIHwgbnVsbCB8IHVuZGVmaW5lZCl9IHNlZ21lbnRzIC0gVGhlIHBhdGggc2VnbWVudHMgdG8gYXBwZW5kIHRvIHRoZSBiYXNlIFVSTC5cbiAqIFRoZXNlIGNhbiBpbmNsdWRlIHN0cmluZ3MsIG51bWJlcnMsIHN5bWJvbHMsIG9yIG51bGwvdW5kZWZpbmVkIHZhbHVlcyAodGhlIGxhdHRlciB0d28gYXJlIGlnbm9yZWQpLlxuICogQHJldHVybnMge3N0cmluZ30gVGhlIGZ1bGx5IGNvbnN0cnVjdGVkIFVSTCwgaW5jbHVkaW5nIHRoZSBiYXNlIFVSTCBhbmQgYWxsIHByb3ZpZGVkIHBhdGggc2VnbWVudHMuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHRzXG4gKiAvLyBSZXR1cm5zICdodHRwczovL3d3dy5kcmFlZ2VyLmNvbS9hYm91dC11cydcbiAqIGNvbnN0IHVybCA9IGJ1aWxkV2Vic2l0ZVVybCgnYWJvdXQtdXMnKTtcbiAqXG4gKiAvLyBDYW4gYWxzbyBoYW5kbGUgbXVsdGlwbGUgc2VnbWVudHMsIHJldHVybmluZyAnaHR0cHM6Ly93d3cuZHJhZWdlci5jb20vcHJvZHVjdHMvc2VhcmNoLzEyMydcbiAqIGNvbnN0IHByb2R1Y3RVcmwgPSBidWlsZFdlYnNpdGVVcmwoJ3Byb2R1Y3RzJywgJ3NlYXJjaCcsIDEyMyk7XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGJ1aWxkV2Vic2l0ZVVybCguLi5zZWdtZW50czogQXJyYXk8c3RyaW5nIHwgbnVtYmVyIHwgc3ltYm9sIHwgbnVsbCB8IHVuZGVmaW5lZD4pOiBzdHJpbmcge1xuICByZXR1cm4gYnVpbGRVcmwoRFJBRUdFUl9XRUJTSVRFX1VSTCwgLi4uc2VnbWVudHMpO1xufVxuIl19