@odx/angular 12.26.1 → 13.0.1

package/components/dropdown/index.d.ts

@@ -1,5 +1,202 @@
-export * from './lib/dropdown.component';
-export * from './lib/dropdown.directive';
-export * from './lib/dropdown.module';
-export * from './lib/helpers';
-export * from './lib/models';
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnChanges, OnDestroy, ViewContainerRef, EventEmitter, Injector } from '@angular/core';
+import { DynamicContent } from '@odx/angular/cdk/dynamic-view';
+import { NgChanges } from '@odx/angular/utils';
+import { ConnectedOverlayOptions } from '@odx/angular/cdk/connected-overlay';
+import * as i2 from '@odx/angular';
+
+declare class CloseDropdownEvent extends Event {
+    static readonly TYPE = "odxDropdownClose";
+    constructor();
+}
+
+type DropdownOptions = Pick<ConnectedOverlayOptions, 'position' | 'containerClass' | 'enableFallback' | 'matchReferenceWidth' | 'minHeight' | 'offset' | 'showArrow' | 'outerPadding'>;
+declare const DefaultDropdownOptions: DropdownOptions;
+
+declare const DEFAULT_DROPDOWN_OPEN_TRIGGERS: string[];
+declare const DEFAULT_DROPDOWN_CLOSE_TRIGGERS: string[];
+/**
+ * Represents a directive that enables dropdown functionality in Angular.
+ * This directive handles the opening and closing of a dropdown menu, as well as
+ * managing the associated overlay and event handling.
+ */
+declare class DropdownDirective implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly changeDetector;
+    private readonly connectedOverlayService;
+    private readonly eventManager;
+    private readonly viewContainer;
+    private readonly injector;
+    private overlayRef;
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * Gets a value indicating whether the dropdown is currently open.
+     *
+     * @returns {boolean}
+     */
+    get isOpen(): boolean;
+    /**
+     * The content to be displayed in the dropdown.
+     * It can be either a static content or a dynamically loaded content.
+     *
+     * @type {DynamicContent | null}
+     */
+    content?: DynamicContent | null;
+    /**
+     * Indicates whether the dropdown is disabled or not.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    disabled: boolean;
+    /**
+     * Indicates whether the loader should be shown.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    showLoader: boolean;
+    /**
+     * Determines whether the dropdown should close when a click event occurs outside of it.
+     *
+     * @type {boolean}
+     * @default true
+     */
+    clickOutsideActive: boolean;
+    /**
+     * The options to be used when creating the dropdown overlay.
+     *
+     * @type {Partial<DropdownOptions> | null}
+     */
+    options?: Partial<DropdownOptions> | null;
+    /**
+     * The reference element to which the dropdown is anchored.
+     *
+     * @type {HTMLElement | null}
+     */
+    referenceElement?: HTMLElement | null;
+    /**
+     * The trigger element that opens the dropdown.
+     *
+     * @type {HTMLElement | null}
+     */
+    triggerElement?: HTMLElement | null;
+    /**
+     * The host element to which the dropdown is appended.
+     *
+     * @type {HTMLElement | ViewContainerRef | null}
+     */
+    host?: HTMLElement | ViewContainerRef | null;
+    /**
+     * The event triggers that open the dropdown.
+     *
+     * @type {string[] | null}
+     * @default DEFAULT_DROPDOWN_OPEN_TRIGGERS
+     */
+    openTrigger?: string[] | null;
+    /**
+     * The event triggers that close the dropdown.
+     *
+     * @type {string[] | null}
+     * @default DEFAULT_DROPDOWN_CLOSE_TRIGGERS
+     */
+    closeTrigger?: string[] | null;
+    /**
+     * Event emitter that emits before the dropdown is opened.
+     *
+     * @emits {void}
+     */
+    beforeOpen: EventEmitter<void>;
+    /**
+     * Event emitter that emits after the dropdown is opened.
+     *
+     * @emits {void}
+     */
+    afterOpen: EventEmitter<void>;
+    /**
+     * Event emitter that emits before the dropdown is closed.
+     *
+     * @emits {void}
+     */
+    beforeClose: EventEmitter<void>;
+    /**
+     * Event emitter that emits after the dropdown is closed.
+     *
+     * @emits {void}
+     */
+    afterClose: EventEmitter<void>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: NgChanges<DropdownDirective>): void;
+    /**
+     * Toggles the state of the dropdown.
+     * If the dropdown is open, it will be closed. If it is closed, it will be opened.
+     *
+     * @param {Event | undefined} event - The optional event that triggered the toggle.
+     */
+    toggle(event?: Event): void;
+    /**
+     * Opens the dropdown.
+     *
+     * @param {Event | undefined} event - The optional event that triggered the open.
+     */
+    open(event?: Event): void;
+    /**
+     * Closes the dropdown.
+     *
+     * @param {Event | undefined} event - The optional event that triggered the close.
+     */
+    close(event?: Event): void;
+    private createOverlayOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownDirective, "[odxDropdown]", ["odxDropdown"], { "content": { "alias": "odxDropdown"; "required": false; }; "disabled": { "alias": "odxDropdownDisabled"; "required": false; }; "showLoader": { "alias": "odxDropdownShowLoader"; "required": false; }; "clickOutsideActive": { "alias": "odxDropdownClickOutsideActive"; "required": false; }; "options": { "alias": "odxDropdownOptions"; "required": false; }; "referenceElement": { "alias": "odxDropdownReferenceElement"; "required": false; }; "triggerElement": { "alias": "odxDropdownTriggerElement"; "required": false; }; "host": { "alias": "odxDropdownHost"; "required": false; }; "openTrigger": { "alias": "odxDropdownOpenTrigger"; "required": false; }; "closeTrigger": { "alias": "odxDropdownCloseTrigger"; "required": false; }; }, { "beforeOpen": "odxDropdownBeforeOpen"; "afterOpen": "odxDropdownAfterOpen"; "beforeClose": "odxDropdownBeforeClose"; "afterClose": "odxDropdownAfterClose"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_showLoader: unknown;
+    static ngAcceptInputType_clickOutsideActive: unknown;
+}
+
+/**
+ * Represents a dropdown component.
+ */
+declare class DropdownComponent {
+    protected readonly host: DropdownDirective;
+    protected readonly injector: Injector;
+    readonly element: i0.ElementRef<HTMLElement>;
+    /**
+     * The content to be displayed in the dropdown.
+     *
+     * @type {DynamicContent | null}
+     */
+    content?: DynamicContent | null;
+    /**
+     * Indicates whether to show a loader while loading the dropdown content.
+     *
+     * @type {boolean | undefined}
+     */
+    showLoader?: boolean;
+    /**
+     * Indicates whether clicking outside the dropdown should close it.
+     *
+     * @type {boolean | undefined}
+     */
+    clickOutsideActive?: boolean;
+    protected onDropdownClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownComponent, "odx-dropdown", never, { "content": { "alias": "content"; "required": false; }; "showLoader": { "alias": "showLoader"; "required": false; }; "clickOutsideActive": { "alias": "clickOutsideActive"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DropdownModule, never, [typeof DropdownDirective], [typeof i2.CoreModule, typeof DropdownDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DropdownModule>;
+}
+
+/**
+ * @internal
+ * Dispatches a CloseDropdownEvent for target to close the current dropdown.
+ *
+ * @param {Element} target - The target element to close the dropdown for.
+ */
+declare function closeCurrentDropdown(target: Element): void;
+
+export { CloseDropdownEvent, DEFAULT_DROPDOWN_CLOSE_TRIGGERS, DEFAULT_DROPDOWN_OPEN_TRIGGERS, DefaultDropdownOptions, DropdownComponent, DropdownDirective, DropdownModule, closeCurrentDropdown };
+export type { DropdownOptions };

package/components/error-page/index.d.ts

@@ -1,2 +1,56 @@
-export * from './lib/error-page.component';
-export * from './lib/error-page.config';
+import * as _odx_angular_components_error_page from '@odx/angular/components/error-page';
+import * as _angular_core from '@angular/core';
+import { EnvironmentProviders } from '@angular/core';
+import { DynamicContent } from '@odx/angular/cdk/dynamic-view';
+import { ConfigDependencies, ConfigProvider } from '@odx/angular/utils';
+
+/**
+ * Represents the ErrorPageComponent class.
+ * This component is responsible for displaying an error page.
+ */
+declare class ErrorPageComponent {
+    readonly element: _angular_core.ElementRef<HTMLElement>;
+    /**
+     * Represents the options for the error page component.
+     *
+     * @type {ErrorPageConfig}
+     */
+    options: _odx_angular_components_error_page.ErrorPageConfig;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ErrorPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ErrorPageComponent, "odx-error-page", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defines the configuration for an error page used within an application. This can include custom icons,
+ * titles, descriptions, actions, and an optional error message.
+ * @property {string} [icon] - The name of the icon to display on the error page (e.g., `core::error`).
+ * @property {DynamicContent} title - The title content for the error page, which can be a string or a dynamic template.
+ * @property {DynamicContent} [description] - Optional description content for the error page.
+ * @property { { label: DynamicContent; action: () => void; }[] } actions - A list of actions that can be taken from the error page, each with a label and an action function.
+ * @property {DynamicContent} [errorMessage] - Optional additional error message content.
+ */
+interface ErrorPageConfig {
+    icon?: string | null;
+    title: DynamicContent;
+    description?: DynamicContent;
+    actions: {
+        label: DynamicContent;
+        action: () => void;
+    }[];
+    errorMessage?: DynamicContent;
+}
+declare const ErrorPageConfig: _angular_core.InjectionToken<Partial<ErrorPageConfig>>;
+declare const ErrorPageDefaultConfig: ErrorPageConfig;
+declare const injectErrorPageConfig: () => ErrorPageConfig;
+declare const provideErrorPageConfig: <D extends ConfigDependencies = ConfigDependencies<Partial<ErrorPageConfig>>>(config: ConfigProvider<Partial<ErrorPageConfig>, D>) => _angular_core.FactoryProvider | _angular_core.ValueProvider;
+/**
+ * Configures and provides the necessary providers for an error page, using a configuration object that specifies
+ * icons, titles, descriptions, and actions.
+ *
+ * @param {ConfigProvider<Partial<ErrorPageConfig>, D>} config - A configuration object or provider function that supplies an `ErrorPageConfig`.
+ * @returns {EnvironmentProviders} Returns a configuration that can be used to register the error page providers.
+ *
+ */
+declare function configureErrorPage<D extends ConfigDependencies>(config: ConfigProvider<Partial<ErrorPageConfig>, D>): EnvironmentProviders;
+
+export { ErrorPageComponent, ErrorPageConfig, ErrorPageDefaultConfig, configureErrorPage, injectErrorPageConfig, provideErrorPageConfig };

package/components/footer/index.d.ts

@@ -1,3 +1,80 @@
-export * from './lib/footer.component';
-export * from './lib/footer.config';
-export * from './lib/models';
+import * as _angular_core from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import * as _odx_angular_components_footer from '@odx/angular/components/footer';
+import { DynamicTextContent } from '@odx/angular/cdk/dynamic-view';
+import * as _odx_angular_utils from '@odx/angular/utils';
+import { MainMenuLinksConfig } from '@odx/angular/components/main-menu';
+
+interface FooterLink {
+    name: string;
+    url: string;
+}
+
+type FooterVariant = (typeof FooterVariant)[keyof typeof FooterVariant];
+declare const FooterVariant: {
+    readonly LIGHT: "light";
+    readonly DARK: "dark";
+};
+
+/**
+ * Represents the footer component of an application, dynamically generating links and supporting various styles.
+ * This component integrates dynamic and static content for the footer, including a logo, navigational links, and a customizable description.
+ */
+declare class FooterComponent {
+    protected readonly footerLinks$: rxjs.Observable<_odx_angular_components_footer.FooterLink[]>;
+    readonly element: _angular_core.ElementRef<HTMLElement>;
+    /**
+     * The description of the footer component.
+     * It can be of type DynamicTextContent or null.
+     *
+     * @type {DynamicTextContent}
+     * @default null
+     */
+    description?: DynamicTextContent | null;
+    /**
+     * The variant of the footer component.
+     *
+     * @type {FooterVariant}
+     * @default FooterVariant.LIGHT
+     */
+    variant: FooterVariant;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FooterComponent, "odx-footer", never, { "description": { "alias": "description"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*", "[odxLink]"], true, never>;
+}
+
+interface FooterLinksConfig extends MainMenuLinksConfig {
+    dynamicLinks?: Observable<FooterLink[]>;
+}
+/**
+ * Creates configuration tokens for the footer links, providing a structured way to inject and manage footer link configurations.
+ * This utility function encapsulates the configuration for footer links, including defaults and the ability to inject custom configurations.
+ *
+ * @returns {Object} An object containing configuration tokens for footer links:
+ * - `FooterLinksConfig`: A token for injecting the footer links configuration.
+ * - `FooterLinksDefaultConfig`: A token representing the default configuration values.
+ * - `injectFooterLinksConfig`: A function to inject the current footer links configuration.
+ * - `provideFooterLinksConfig`: A function to provide a custom configuration for footer links.
+ *
+ * @example
+ * ```ts
+ * // In your module or component
+ * @NgModule({
+ *   providers: [
+ *     provideFooterLinksConfig({
+ *       legalNoticeUrl: 'https://www.custom-url/legal-notice',
+ *       providerIdentificationUrl: 'https://www.custom-url/provider-identification',
+ *       dynamicLinks: myDynamicLinksObservable
+ *     })
+ *   ]
+ * })
+ * export class MyModule {}
+ * ```
+ */
+declare const FooterLinksConfig: _angular_core.InjectionToken<Partial<FooterLinksConfig>>;
+declare const FooterLinksDefaultConfig: FooterLinksConfig;
+declare const injectFooterLinksConfig: () => FooterLinksConfig;
+declare const provideFooterLinksConfig: <D extends _odx_angular_utils.ConfigDependencies = _odx_angular_utils.ConfigDependencies<Partial<FooterLinksConfig>>>(config: _odx_angular_utils.ConfigProvider<Partial<FooterLinksConfig>, D>) => _angular_core.FactoryProvider | _angular_core.ValueProvider;
+
+export { FooterComponent, FooterLinksConfig, FooterLinksDefaultConfig, FooterVariant, injectFooterLinksConfig, provideFooterLinksConfig };
+export type { FooterLink };