@odx/angular 12.26.1 → 13.0.1

package/lib/tokens/stringify.d.ts

@@ -1,45 +0,0 @@
-import { InjectionToken } from '@angular/core';
-/**
- * A function type that defines the logic to convert an item of any type into a string.
- * The function should handle various types gracefully, returning a meaningful string representation
- * for each. If the item is not present (null or undefined), an empty string should be returned.
- *
- * @template T The type of the item to be stringified.
- * @param {T} item - The item to stringify.
- * @returns {string} The string representation of the item.
- *
- * @example
- * ```ts
- * // A simple stringify function that handles null and undefined
- * const stringify: StringifyFn<unknown> = (item) => (isPresent(item) ? String(item) : '');
- * console.log(stringify(123)); // Outputs: "123"
- * console.log(stringify(null)); // Outputs: ""
- * ```
- */
-export type StringifyFn<T> = (item: T) => string;
-/**
- * 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 declare const ODX_STRINGIFY: InjectionToken<StringifyFn<unknown>>;

package/localization/lib/features/index.d.ts

@@ -1,2 +0,0 @@
-export * from './with-http-language-header';
-export * from './with-http-language-query-param';

package/localization/lib/features/with-http-language-header.d.ts

@@ -1,72 +0,0 @@
-import { HttpInterceptorFn } from '@angular/common/http';
-import { LocalizationFeature } from '../models';
-export declare const HTTP_LANGUAGE_HEADER = "Accept-Language";
-/**
- * Configuration object for the HTTP language header interceptor. It specifies which URLs
- * the interceptor should apply to and allows customizing the name of the header used to transmit
- * the current language setting.
- *
- * @property {Array<string | RegExp>} allowedUrls - An array of strings or RegExp patterns
- * indicating the URLs to which the language header should be added.
- * @property {string} [headerName=HTTP_LANGUAGE_HEADER] - Optional. The name of the HTTP header
- * through which the current language setting will be transmitted. Defaults to 'Accept-Language'.
- */
-export interface HttpLanguageHeaderInterceptorConfig {
-    allowedUrls: Array<string | RegExp>;
-    headerName?: string;
-}
-/**
- * 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 declare function httpLanguageHeaderInterceptor({ allowedUrls, headerName }: HttpLanguageHeaderInterceptorConfig): HttpInterceptorFn;
-/**
- * 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 declare function withHttpLanguageHeader(config: HttpLanguageHeaderInterceptorConfig): LocalizationFeature;

package/localization/lib/features/with-http-language-query-param.d.ts

@@ -1,70 +0,0 @@
-import { HttpInterceptorFn } from '@angular/common/http';
-import { LocalizationFeature } from '../models';
-export declare const HTTP_LANGUAGE_QUERY = "language";
-/**
- * Defines the configuration options for the HTTP interceptor that appends the current
- * language setting as a query parameter to outgoing requests. This configuration specifies
- * which requests should have the language parameter appended based on their URLs.
- *
- * @property {Array<string | RegExp>} allowedUrls - URLs (or patterns matching URLs) to which
- * the language query parameter should be appended.
- * @property {string} [queryParamName=HTTP_LANGUAGE_QUERY] - The name of the query parameter
- * used to transmit the current language. Defaults to 'language'.
- */
-export interface HttpLanguageQueryParamInterceptorConfig {
-    allowedUrls: Array<string | RegExp>;
-    queryParamName?: string;
-}
-/**
- * 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 declare function withHttpLanguageQueryParamInterceptor({ allowedUrls, queryParamName }: HttpLanguageQueryParamInterceptorConfig): HttpInterceptorFn;
-/**
- * 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 declare function withHttpLanguageQueryParam(config: HttpLanguageQueryParamInterceptorConfig): LocalizationFeature;

package/localization/lib/loaders/browser-language-loader.d.ts

@@ -1,34 +0,0 @@
-import { LanguageLoaderFn } from '../models';
-/**
- * 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 declare const browserLanguageLoader: LanguageLoaderFn;

package/localization/lib/loaders/index.d.ts

@@ -1 +0,0 @@
-export * from './browser-language-loader';

package/localization/lib/localization.config.d.ts

@@ -1,90 +0,0 @@
-import { EnvironmentProviders } from '@angular/core';
-import { LanguageLoaderFn, LocalizationFeature } from './models';
-export declare const DEFAULT_AVAILABLE_LANGUAGES: string[];
-/**
- * Defines the structure for the localization configuration used throughout the application.
- * It allows specifying available languages, and includes an optional loader
- * function for dynamically determining the active language.
- *
- * @property {LanguageLoaderFn} [activeLanguageLoader] Optional function for loading the
- * active language dynamically, useful for scenarios where the application's language
- * needs to be determined based on user settings, browser settings, or external data.
- * @property {string[]} availableLanguages An array of language codes representing the
- * languages available in the application.
- */
-export interface LocalizationConfig {
-    activeLanguageLoader?: LanguageLoaderFn;
-    availableLanguages: string[];
-}
-/**
- * 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 declare const LocalizationConfig: import("@angular/core").InjectionToken<Partial<LocalizationConfig>>, LocalizationDefaultConfig: LocalizationConfig, injectLocalizationConfig: () => LocalizationConfig, provideLocalizationConfig: <D extends import("@odx/angular/utils").ConfigDependencies = import("@odx/angular/utils").ConfigDependencies<Partial<LocalizationConfig>>>(config: import("@odx/angular/utils").ConfigProvider<Partial<LocalizationConfig>, D>) => import("@angular/core").FactoryProvider | import("@angular/core").ValueProvider;
-/**
- * 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 declare function provideLocalization(config: Partial<LocalizationConfig>, ...features: LocalizationFeature[]): EnvironmentProviders;

package/localization/lib/localization.logger.d.ts

@@ -1,3 +0,0 @@
-import { Logger } from '@odx/angular/internal';
-declare const _default: Logger;
-export default _default;

package/localization/lib/localization.service.d.ts

@@ -1,56 +0,0 @@
-import { Observable } from 'rxjs';
-import * as i0 from "@angular/core";
-export declare class LocalizationService {
-    private readonly localizationConfig;
-    private readonly injector;
-    private readonly localeState$;
-    /**
-     * Represents an observable stream of the active language in the localization service.
-     * The active language is determined by the locale state.
-     *
-     * @emits {string} The active language.
-     */
-    readonly activeLanguage$: Observable<string>;
-    /**
-     * Gets the list of available languages for localization.
-     *
-     * @type {string[]} The list of available languages.
-     */
-    readonly availableLanguages: string[];
-    /** Default language derived from the first entry in the available languages list.
-     *
-     * @type {string}
-     */
-    readonly defaultLanguage: string;
-    /**
-     * Retrieves the currently active language. Falls back to the default language if
-     * no active language is set.
-     *
-     * @returns {string} Full locale name e.g. 'en-US' or just 'en' if no region info is attached.
-     */
-    getActiveLanguage(): string;
-    /**
-     * Retrieves the active language subtag.
-     *
-     * @returns {string} The two-digit language subtag, e.g. 'en', 'fr'.
-     */
-    getActiveLanguageSubtag(): string;
-    /**
-     * Sets the active language based on the provided language code. If the language is not
-     * recognized, it logs an error and does not change the active language.
-     *
-     * @param {string} language The language code to set as the active language.
-     */
-    setActiveLanguage(language: string): void;
-    /**
-     * Loads the active language for the localization service.
-     * This method runs in an injection context and sets the active language based on the result of the active language loader.
-     * If the active language loader fails, the default language is set as the active language.
-     *
-     * @returns {Promise<void>} A promise that resolves when the active language is loaded and set.
-     */
-    loadActiveLanguage(): Promise<void>;
-    private createActiveLanguageLoader$;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<LocalizationService>;
-}

package/localization/lib/models/index.d.ts

@@ -1,2 +0,0 @@
-export * from './language-loader-fn';
-export * from './localization-feature';

package/localization/lib/models/language-loader-fn.d.ts

@@ -1,2 +0,0 @@
-import { Observable } from 'rxjs';
-export type LanguageLoaderFn = () => Observable<string | undefined> | Promise<string | undefined> | string | undefined;

package/localization/lib/models/localization-feature.d.ts

@@ -1,12 +0,0 @@
-import { EnvironmentProviders, Provider } from '@angular/core';
-export type LocalizationFeature = EnvironmentProviders & {
-    ɵodxBrand: '@odx/angular/localization::LocalizationFeature';
-};
-/**
- * @internal
- * Creates a feature provider for the localization module.
- *
- * @param {Provider[] | EnvironmentProviders} provider - The providers to be used for the localization feature.
- * @returns {LocalizationFeature} The localization feature provider.
- */
-export declare function makeLocalizationFeature(provider: Provider[] | EnvironmentProviders): LocalizationFeature;

package/rxjs/lib/delay-until.d.ts

@@ -1,24 +0,0 @@
-import { MonoTypeOperatorFunction, Observable } from 'rxjs';
-/**
- * Delays the emission of each value from the source Observable by a time span determined by the `delay` function.
- * If the `notifier` Observable emits before the delay expires, the delayed emission is cancelled.
- *
- * This operator is useful for postponing the observable emissions until certain conditions are met,
- * represented by the passage of time defined by `delay`. It also allows for a way to preemptively
- * cancel the delay in response to another observable's emission.
- *
- * @template T The type of items emitted by the source Observable.
- * @param {() => number} delay A function that returns the delay (in milliseconds) before the source Observable's values are emitted.
- * @param {Observable<unknown>} notifier An Observable that cancels the delay when it emits.
- * @returns {MonoTypeOperatorFunction<T>} An Observable that emits the source Observable's items with a delay if not cancelled.
- * @example
- * ```ts
- * // Delay each number emission by 1 second, unless the 'cancel' button is clicked.
- * const delayedNumbers$ = of(1, 2, 3).pipe(
- *   delayUntil(() => 1000, fromEvent(cancelButton, 'click'))
- * );
- *
- * delayedNumbers$.subscribe(console.log);
- * ```
- */
-export declare function delayUntil<T>(delay: () => number, notifier: Observable<unknown>): MonoTypeOperatorFunction<T>;

package/rxjs/lib/from-element-mutation.d.ts

@@ -1,23 +0,0 @@
-import { Observable } from 'rxjs';
-/**
- * Creates an RxJS Observable that emits mutation records for changes in a DOM element's attributes,
- * child list, and subtree. It uses the `MutationObserver` Web API to observe mutations on the specified
- * element according to the options provided.
- *
- * @param {Element} element The DOM element to observe for mutations.
- * @param {MutationObserverInit} options An object that specifies which DOM mutations should be reported.
- * Options include attributes, childList, subtree, attributeOldValue, characterData, characterDataOldValue,
- * and attributeFilter.
- * @returns {Observable<MutationRecord>} An Observable that emits a `MutationRecord` each time a mutation
- * matching the specified options occurs in the observed element.
- * @example
- * ```ts
- * // Observing changes to the child list of an element
- * const element = document.getElementById('my-element');
- * const mutationOptions = { childList: true };
- *
- * fromElementMutation$(element, mutationOptions).subscribe((mutation) => console.log('Mutation detected:', mutation));
- * ```
- * Note: Always remember to unsubscribe from the observable to prevent memory leaks.
- */
-export declare function fromElementMutation$(element: Element, options: MutationObserverInit): Observable<MutationRecord>;

package/rxjs/lib/from-element-resize.d.ts

@@ -1,26 +0,0 @@
-import { Observable } from 'rxjs';
-/**
- * Creates an RxJS Observable that emits an array of `ResizeObserverEntry` objects whenever
- * the target element's size changes. This function provides a reactive way to observe
- * and respond to changes in an element's dimensions, using the `ResizeObserver` Web API.
- *
- * The observable debounces the emitted values to improve performance and reduce the frequency
- * of change detection runs in Angular applications. The debounce time can be adjusted via
- * the `debounceDuration` parameter.
- *
- * @param {Element} element The DOM element to observe for size changes.
- * @param {number} [debounceDuration=50] The time, in milliseconds, to debounce the emitted
- * values. Defaults to 50ms.
- * @returns {Observable<ResizeObserverEntry[]>} An Observable that emits the resize events
- * for the observed element. Each emission is an array of `ResizeObserverEntry` objects, one
- * for each observed element that experienced a resize.
- * @example
- * ```ts
- * // Observing resize events of an element with a 100ms debounce duration
- * const element = document.getElementById('resizable-element');
- * fromElementResize$(element, 100).subscribe((entries) => console.log('Element resized:', entries));
- * ```
- *
- * Always unsubscribe from the observable to clean up resources and prevent memory leaks.
- */
-export declare function fromElementResize$(element: Element, debounceDuration?: number): Observable<ResizeObserverEntry[]>;

package/rxjs/lib/from-events.d.ts

@@ -1,27 +0,0 @@
-import { Observable } from 'rxjs';
-import { HasEventTargetAddRemove } from 'rxjs/internal/observable/fromEvent';
-/**
- * Creates an Observable that emits events of a specific type from one or multiple event targets.
- * It listens to multiple event types on the given target(s) and emits the events through a single
- * Observable stream, simplifying the handling of related event types.
- *
- * @template T The event object type that the Observable will emit.
- * @param {HasEventTargetAddRemove<T> | HasEventTargetAddRemove<T>[]} target The DOM element(s) or event target(s) to listen on.
- * @param {...string[]} events The names of the events to listen for on the target(s).
- * @returns {Observable<T>} An Observable that emits an event each time one of the specified events occurs on the given target(s).
- *
- * @example
- * ```ts
- * // Listen to both 'click' and 'keyup' events on document
- * fromEvents(document, 'click', 'keyup').subscribe(event => {
- *   console.log('Event occurred:', event);
- * });
- *
- * // Listen to 'mousemove' event on multiple elements
- * const elements = [document.getElementById('first'), document.getElementById('second')];
- * fromEvents(elements, 'mousemove').subscribe(event => {
- *   console.log('Mouse moved over:', event.target);
- * });
- * ```
- */
-export declare function fromEvents<T>(target: HasEventTargetAddRemove<T> | HasEventTargetAddRemove<T>[], ...events: string[]): Observable<T>;

package/rxjs/lib/from-query-list.d.ts

@@ -1,22 +0,0 @@
-import { QueryList } from '@angular/core';
-import { Observable } from 'rxjs';
-/**
- * Creates an Observable from an Angular QueryList. The Observable emits the initial state
- * of the QueryList and continues to emit updates every time the QueryList changes.
- * This utility function is useful for integrating Angular's QueryList changes into
- * the RxJS reactive data flow, allowing developers to apply RxJS operators and
- * subscriptions to respond to QueryList updates.
- *
- * @template T The type of elements contained within the QueryList.
- * @param {QueryList<T>} queryList The QueryList instance to observe.
- * @returns {Observable<QueryList<T>>} An Observable that emits the current state of the QueryList
- * and updates whenever the QueryList changes.
- * @example
- * ```ts
- * // Assuming 'items' is a QueryList of component instances or DOM elements
- * fromQueryList(items).subscribe(queryList => {
- *   console.log('QueryList changed:', queryList);
- * });
- * ```
- */
-export declare function fromQueryList<T>(queryList: QueryList<T>): Observable<QueryList<T>>;

package/sdk/lib/application-environment.d.ts

@@ -1,68 +0,0 @@
-import { ApplicationRef, InjectionToken } from '@angular/core';
-/**
- * A function type definition for loading environment data for an application.
- * It's a generic loader function that accepts parameters and returns a Promise of environment data.
- *
- * @template EnvironmentData The type of the environment data to be loaded.
- * @template Params The types of the parameters accepted by the loader function.
- * @param {...Params} args - Parameters passed to the loader function.
- * @returns {Promise<EnvironmentData>} A promise resolving to the loaded environment data.
- */
-export type ApplicationEnvironmentLoader<EnvironmentData, Params extends unknown[]> = (...args: Params) => Promise<EnvironmentData>;
-/**
- * Creates a loader function for fetching application environment data over HTTP and caching it.
- * Utilizes `CacheStorageClient` for caching the fetched data to optimize performance and reduce network load.
- *
- * @template Data The type of the data expected from the HTTP request.
- * @param {Function} handler - A function that processes the fetched data and returns a promise resolving to the desired environment data format.
- * @returns {ApplicationEnvironmentLoader<Data, Parameters<CacheStorageClient['request']>>} A loader function that fetches, caches, and processes environment data.
- * @example
- * const environmentLoader = createHttpApplicationEnvironmentLoader(async (dto) => {
- *   return { apiEndpoint: dto.apiEndpoint, featureFlags: dto.featureFlags };
- * });
- */
-export declare function createHttpApplicationEnvironmentLoader<Data>(handler: (dto: unknown) => Promise<Data>): ApplicationEnvironmentLoader<Data, Parameters<typeof fetch>>;
-/**
- * The application environment module can be used to load environment data before application startup,
- * that can be used to load environment variables from an external URL.
- *
- * @template Data The type of the environment data.
- * @template Params The types of the parameters accepted by the loader function.
- * @param {ApplicationEnvironmentLoader<Data, Params>} loader - A loader function that asynchronously loads the environment data.
- * @returns An object containing utilities for working with the application environment, including the InjectionToken
- *          and functions for loading and bootstrapping the application with the environment.
- * @example
- * To add an application environment to your Angular application, follow the following steps:
- * 1. Create the application environment with your loader:
- * ```ts
- * import { createApplicationEnvironment, createHttpApplicationEnvironmentLoader } from '@odx/angular/sdk';
- * import { z } from 'zod';
- *
- * export const ApplicationConfigSchema = z.object({
- *   environment: z.enum(['dev', 'stage', 'prod']),
- *   appName: z.string().default('App'),
- * });
- *
- * const httpEnvironmentLoader = createHttpApplicationEnvironmentLoader((res) => res.json().then(ApplicationConfigSchema.parse));
- * export const { injectApplicationEnvironment, bootstrapApplicationWithEnvironment } = createApplicationEnvironment(httpEnvironmentLoader);
- * ```
- * This example creates an HTTP environment loader which parses the response as JSON and validate it against a schema
- *
- * 2. Provide the application environment:
- * ```ts
- * bootstrapApplicationWithEnvironment(['assets/config.json'], AppComponent, { providers: [] });
- * ```
- *
- * 3. Use the application environment via DI
- * ```ts
- * class MyService {
- *   private readonly environment = injectApplicationEnvironment();
- * }
- * ```
- */
-export declare function createApplicationEnvironment<Data, Params extends unknown[]>(loader: ApplicationEnvironmentLoader<Data, Params>): {
-    APPLICATION_ENVIRONMENT: InjectionToken<Data>;
-    injectApplicationEnvironment: () => Data;
-    bootstrapApplicationWithEnvironment: (params: Parameters<typeof loader>, rootComponent: import("@angular/core").Type<unknown>, options?: import("@angular/core").ApplicationConfig | undefined) => Promise<ApplicationRef>;
-    loadApplicationEnvironment: (...args: Parameters<typeof loader>) => Promise<Data>;
-};

package/theming/lib/helpers/index.d.ts

@@ -1,3 +0,0 @@
-export * from './prefers-dark-theme';
-export * from './resolve-theme';
-export * from './theme-storage';

package/theming/lib/helpers/prefers-dark-theme.d.ts

@@ -1,19 +0,0 @@
-/**
- * Determines whether the user's system preferences indicate a preference for dark themes.
- * This is achieved by querying the '(prefers-color-scheme: dark)' media feature, which reflects
- * the user's preference for a light or dark color scheme in their operating system's UI.
- *
- * @param {Window} view - The window object, typically `window`, from which to access the matchMedia method.
- * @returns {boolean} `true` if the user prefers a dark theme, otherwise `false`.
- *
- * @example
- * Example usage in a web application to toggle themes:
- * ```ts
- * if (prefersDarkTheme(window)) {
- *   document.body.classList.add('dark-theme');
- * } else {
- *   document.body.classList.remove('dark-theme');
- * }
- * ```
- */
-export declare function prefersDarkTheme(view: Window): boolean;