@acorex/platform 19.4.15 → 20.0.0-next.0

package/layout/components/index.d.ts

@@ -1,4 +1,436 @@
-export * from './lib/user-avatar';
-export * from './lib/badge';
-export * from './lib/blocks';
-export * from './lib/component-slot';
+import { Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy, Signal, InputSignal, TemplateRef, ElementRef, Type, ViewContainerRef, ModuleWithProviders } from '@angular/core';
+import { AXHtmlEvent } from '@acorex/cdk/common';
+import { AXPMenuItem } from '@acorex/platform/common';
+import * as _acorex_platform_core from '@acorex/platform/core';
+import { AXPContextData, AXPActivityLog, AXPSystemActionType } from '@acorex/platform/core';
+import * as _ngrx_signals from '@ngrx/signals';
+import { AXPWidgetNode } from '@acorex/platform/layout/builder';
+
+type AXPUserAvatarSize = 'small' | 'medium' | 'large';
+type AXPUserAvatarStatus = 'online' | 'offline';
+type AXPUserAvatarData = {
+    id: string;
+    status: AXPUserAvatarStatus;
+    username: string;
+    firstName: string;
+    lastName?: string;
+    avatarUrl?: string;
+};
+interface AXPUserAvatarProvider {
+    provide(userId: string): Promise<AXPUserAvatarData>;
+}
+
+declare class AXPUserAvatarService {
+    private provider;
+    private readonly cacheExpiryTime;
+    private readonly refreshInterval;
+    private cache;
+    /**
+     * Gets user information with caching and auto-refresh
+     * @param userId The username to fetch information for
+     * @returns Observable that emits user avatar data
+     */
+    getUserInfo$(userId: string): Observable<AXPUserAvatarData>;
+    /**
+     * Gets user information (Promise-based for backward compatibility)
+     * @param userId The username to fetch information for
+     * @returns Promise that resolves to user avatar data
+     */
+    getUserInfo(userId: string): Promise<AXPUserAvatarData>;
+    /**
+     * Clears the entire cache or a specific user's cache
+     * @param userId Optional username to clear specific cache
+     */
+    clearCache(userId?: string): void;
+    /**
+     * Force refresh data for a specific username
+     * @param userId The username to refresh
+     * @returns Promise that resolves to the refreshed data
+     */
+    refreshUserInfo(userId: string): Promise<AXPUserAvatarData>;
+    /**
+     * Checks if a cache entry is expired
+     */
+    private isExpired;
+    /**
+     * Fetches data from provider and updates the cache
+     */
+    private fetchAndUpdateCache;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPUserAvatarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPUserAvatarService>;
+}
+
+declare const AXP_USER_AVATAR_PROVIDER: InjectionToken<AXPUserAvatarProvider>;
+
+declare class AXPUserAvatarComponent implements OnInit, OnDestroy {
+    private readonly userAvatarService;
+    private readonly destroy$;
+    protected userInfo: i0.WritableSignal<AXPUserAvatarData | null>;
+    size: i0.InputSignal<number>;
+    userId: i0.InputSignal<string>;
+    src: i0.WritableSignal<string>;
+    userName: i0.Signal<string>;
+    firstName: i0.Signal<string>;
+    lastName: i0.Signal<string>;
+    title: i0.Signal<string>;
+    isOnline: i0.Signal<boolean>;
+    avatarText: i0.Signal<string>;
+    avatarColor: i0.Signal<string>;
+    protected hasPicture: i0.WritableSignal<boolean>;
+    protected onImageError(event: AXHtmlEvent<ErrorEvent>): void;
+    protected onImageLoad(event: AXHtmlEvent<Event>): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private loadUserData;
+    /**
+     * Generate avatar image source
+     * This is a placeholder - implement based on your actual requirements
+     */
+    private generateAvatarSrc;
+    /**
+     * Get initials from first and last name
+     */
+    private getInitials;
+    private hashString;
+    private pickColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPUserAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPUserAvatarComponent, "axp-user-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "userId": { "alias": "userId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPTaskBadgeService {
+    private badgeMap;
+    private providers;
+    private computedCache;
+    constructor();
+    getCount(key: string): Signal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTaskBadgeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPTaskBadgeService>;
+}
+
+declare const AXP_TASK_BADGE_PROVIDERS: InjectionToken<AXPTaskBadgeProvider[]>;
+declare abstract class AXPTaskBadgeProvider {
+    abstract key: string;
+    abstract count: Signal<number>;
+}
+
+declare class AXPTaskBadgeDirective {
+    #private;
+    private badgeService;
+    private host;
+    private hostElement;
+    badgeKey: InputSignal<string | undefined>;
+    count: InputSignal<number>;
+    private readonly displayCount;
+    private setValueOfInputSignal;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTaskBadgeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPTaskBadgeDirective, "[axp-task-badge]", never, { "badgeKey": { "alias": "badgeKey"; "required": false; "isSignal": true; }; "count": { "alias": "axp-task-badge"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPMenuBadgeHelper {
+    private static cache;
+    static getTotalCount(item: AXPMenuItem, badgeService: AXPTaskBadgeService): Signal<number>;
+}
+
+declare class AXPThemeLayoutPagePrimaryActionsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutPagePrimaryActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutPagePrimaryActionsComponent, "axp-layout-actions-primary", never, {}, {}, never, ["ax-button,ax-dropdown-button"], true, never>;
+}
+declare class AXPThemeLayoutPageSecondaryActionsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutPageSecondaryActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutPageSecondaryActionsComponent, "axp-layout-actions-secondary", never, {}, {}, never, ["ax-button-item,ax-divider,ng-container"], true, never>;
+}
+declare class AXPThemeLayoutActionsComponent {
+    readonly primaryTemplate: i0.Signal<TemplateRef<any> | undefined>;
+    private readonly primaryContent;
+    hasPrimary: i0.Signal<boolean>;
+    readonly secondaryTemplate: i0.Signal<TemplateRef<any> | undefined>;
+    private readonly secondaryContent;
+    hasSecondary: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutActionsComponent, "axp-layout-actions", never, {}, {}, ["primaryContent", "secondaryContent"], ["axp-layout-actions-primary", "axp-layout-actions-secondary", "*"], true, never>;
+}
+
+declare class AXPThemeLayoutBlockComponent {
+    protected readonly elementRef: ElementRef<any>;
+    readonly hostElement: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutBlockComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutBlockComponent, "    axp-page-content,     axp-page-footer-container,    axp-page-footer,    axp-page-header,    axp-page-header-container,    axp-page-toolbar,    axp-layout-content,     axp-layout-page-content,     axp-layout-sections,    axp-layout-body,    axp-layout-page-body,    axp-layout-prefix,    axp-layout-suffix,    axp-layout-title-bar,    axp-layout-title,     axp-layout-title-actions,     axp-layout-nav-button,     axp-layout-description,     axp-layout-breadcrumbs,    axp-layout-list-action,    ", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class AXPThemeLayoutFooterComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutFooterComponent, "axp-layout-footer, axp-layout-page-footer", never, {}, {}, never, ["axp-layout-prefix", "axp-layout-suffix"], true, never>;
+}
+
+declare class AXPThemeLayoutPageHeaderComponent {
+    readonly title: i0.Signal<TemplateRef<any> | undefined>;
+    readonly description: i0.Signal<TemplateRef<any> | undefined>;
+    readonly actions: i0.Signal<TemplateRef<any> | undefined>;
+    readonly navbar: i0.Signal<TemplateRef<any> | undefined>;
+    readonly breadcrumbs: i0.Signal<TemplateRef<any> | undefined>;
+    readonly navButton: i0.Signal<TemplateRef<any> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutPageHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutPageHeaderComponent, "axp-layout-page-header", never, {}, {}, never, ["axp-layout-breadcrumbs", "axp-layout-toolbar", "axp-layout-actions", "axp-layout-description", "axp-layout-title", "axp-layout-nav-button"], true, never>;
+}
+declare class AXPThemeLayoutHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutHeaderComponent, "axp-layout-header", never, {}, {}, never, ["axp-layout-prefix", "*", "axp-layout-suffix"], true, never>;
+}
+
+declare class AXPThemeLayoutListComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutListComponent, "axp-layout-list", never, {}, {}, never, ["axp-layout-list-item,axp-layout-list-group,ng-container"], true, never>;
+}
+declare class AXPThemeLayoutListItemsGroupComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutListItemsGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutListItemsGroupComponent, "axp-layout-list-group", never, {}, {}, never, ["axp-layout-list-item, axp-layout-title, axp-layout-header ,ng-container"], true, never>;
+}
+declare class AXPThemeLayoutListItemComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutListItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutListItemComponent, "axp-layout-list-item", never, {}, {}, never, ["axp-layout-content,axp-layout-prefix,axp-layout-suffix,ng-container"], true, never>;
+}
+
+declare class AXPThemeLayoutSectionComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutSectionComponent, "axp-layout-section", never, {}, {}, never, ["axp-layout-header", "axp-layout-content"], true, never>;
+}
+
+declare class AXPThemeLayoutStartSideComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutStartSideComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutStartSideComponent, "axp-layout-page-start-side, axp-layout-start-side", never, {}, {}, never, ["axp-layout-header", "axp-layout-content", "axp-layout-footer", "*"], true, never>;
+}
+declare class AXPThemeLayoutEndSideComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutEndSideComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutEndSideComponent, "axp-layout-page-end-side, axp-layout-end-side", never, {}, {}, never, ["axp-layout-header", "axp-layout-content", "axp-layout-footer"], true, never>;
+}
+
+declare class AXPThemeLayoutToolbarComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutToolbarComponent, "axp-layout-toolbar", never, {}, {}, never, ["axp-layout-prefix", "axp-layout-suffix", "*"], true, never>;
+}
+
+declare class AXPThemeLayoutContainerComponent {
+    protected readonly elementRef: ElementRef<HTMLDivElement>;
+    readonly hostElement: HTMLDivElement;
+    private _isEmptySignal;
+    readonly isEmpty: Signal<boolean>;
+    private mutationObserver?;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPThemeLayoutContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPThemeLayoutContainerComponent, "axp-layout-container", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface AXPComponentSlotConfig {
+    name: string;
+    priority?: number;
+    component?: Type<any>;
+    condition?: ((context?: AXPContextData) => (boolean | Promise<boolean>)) | string;
+    loadComponent?: () => Type<any> | Promise<Type<any>>;
+    options?: {
+        [key: string]: unknown;
+    } | (() => {
+        [key: string]: unknown;
+    });
+}
+interface AXPComponentSlotModuleConfigs {
+    [slotName: string]: AXPComponentSlotConfig[];
+}
+declare abstract class AXPComponentSlot {
+    host: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPComponentSlot, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPComponentSlotDirective implements OnInit {
+    name: i0.InputSignal<string>;
+    host: i0.InputSignal<any>;
+    context: i0.InputSignal<any>;
+    private elementRef;
+    private registryService;
+    private injector;
+    private evaluator;
+    viewContainerRef: ViewContainerRef;
+    contextStore: {
+        data: i0.Signal<AXPContextData>;
+        state: i0.Signal<_acorex_platform_core.AXPContextState>;
+        initialSnapshot: _ngrx_signals.DeepSignal<{}>;
+        previousSnapshot: _ngrx_signals.DeepSignal<{}>;
+        lastChange: _ngrx_signals.DeepSignal<_acorex_platform_core.AXPContextChangeEvent>;
+        isChanged: i0.Signal<boolean>;
+        isReset: i0.Signal<boolean>;
+        isInitiated: i0.Signal<boolean>;
+        isEmpty: i0.Signal<boolean>;
+        snapshot: i0.Signal<AXPContextData>;
+        initial: i0.Signal<{}>;
+        previous: i0.Signal<{}>;
+        changeEvent: i0.Signal<_acorex_platform_core.AXPContextChangeEvent>;
+        update: (path: string, value: any) => void;
+        patch: (context: {}) => void;
+        reset: () => void;
+        set: (initialData: any) => void;
+        getValue: (path: string) => any;
+    } & _ngrx_signals.StateSource<{
+        data: AXPContextData;
+        state: _acorex_platform_core.AXPContextState;
+        initialSnapshot: {};
+        previousSnapshot: {};
+        lastChange: _acorex_platform_core.AXPContextChangeEvent;
+    }>;
+    isEmpty: i0.Signal<boolean>;
+    private _viewCount;
+    ngOnInit(): Promise<void>;
+    loadComponents(): Promise<void>;
+    private evaluateCondition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlotDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPComponentSlotDirective, "axp-component-slot", ["slot"], { "name": { "alias": "name"; "required": true; "isSignal": true; }; "host": { "alias": "host"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class AXPComponentSlotRegistryService {
+    private registry;
+    register(slotName: string, config: AXPComponentSlotConfig): void;
+    get(slotName: string): AXPComponentSlotConfig[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlotRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPComponentSlotRegistryService>;
+}
+
+declare class AXPComponentSlotModule {
+    static forRoot(configs?: AXPComponentSlotModuleConfigs): ModuleWithProviders<AXPComponentSlotModule>;
+    static forChild(configs?: AXPComponentSlotModuleConfigs): ModuleWithProviders<AXPComponentSlotModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlotModule, [{ optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPComponentSlotModule, [typeof AXPComponentSlotDirective], never, [typeof AXPComponentSlotDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPComponentSlotModule>;
+}
+
+declare class AXPActivityLogComponent {
+    private readonly translateService;
+    private readonly workflowService;
+    /**
+     * Array of activity logs to display
+     */
+    activities: i0.InputSignal<AXPActivityLog[]>;
+    /**
+     * Whether the component is in loading state
+     */
+    loading: i0.InputSignal<boolean>;
+    protected readonly i18nScope = "activity-log";
+    protected readonly Object: ObjectConstructor;
+    /**
+     * Set of expanded activity IDs
+     */
+    private expandedItems;
+    /**
+     * Flag to track if component has been initialized
+     */
+    private isInitialized;
+    /**
+     * Set of items that have been manually toggled (for animation control)
+     */
+    private manuallyToggledItems;
+    constructor();
+    /**
+     * Gets the appropriate CSS class for the change type
+     */
+    protected getChangeClasses(changeType: AXPSystemActionType): {
+        surface: string;
+        text: string;
+        icon: string;
+    };
+    /**
+ * Checks if an activity item is expanded
+ */
+    protected isExpanded(activityId: string): boolean;
+    /**
+ * Toggles the expanded state of an activity item
+ */
+    protected toggleExpanded(activityId: string): void;
+    /**
+     * Checks if an item should have expand/collapse animation
+     */
+    protected shouldAnimate(activityId: string): boolean;
+    /**
+     * Checks if an activity has expandable content (changes)
+     */
+    protected hasExpandableContent(activity: AXPActivityLog): boolean;
+    /**
+     * Handles the compare action for an activity
+     */
+    protected handleCompare(activity: AXPActivityLog, event: Event): Promise<void>;
+    /**
+     * Checks if an activity can be compared (has a previous version)
+     */
+    protected canCompare(activity: AXPActivityLog): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityLogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPActivityLogComponent, "axp-activity-log", never, { "activities": { "alias": "activities"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface AXPCompareViewField {
+    path: string;
+    title: string;
+    description?: string;
+    widget: AXPWidgetNode;
+}
+interface AXPCompareViewObject {
+    id: string;
+    title: string;
+    description?: string;
+    context: AXPContextData;
+}
+interface AXPCompareViewInputs {
+    fields: AXPCompareViewField[];
+    objects: AXPCompareViewObject[];
+}
+type AXPCompareViewMode = 'compare' | 'changes';
+declare class AXPCompareViewComponent implements OnInit, OnDestroy {
+    inputs: i0.InputSignal<AXPCompareViewInputs | undefined>;
+    showOnlyChanges: i0.WritableSignal<boolean>;
+    mode: i0.InputSignal<AXPCompareViewMode>;
+    private removedObjects;
+    protected isChangesMode: i0.Signal<boolean>;
+    /**
+     * Filtered fields based on showOnlyChanges toggle
+     */
+    filteredFields: i0.Signal<AXPCompareViewField[]>;
+    remainingObjects: i0.Signal<AXPCompareViewObject[]>;
+    /**
+     * Check if a field value will change in the next object (to show arrow in current cell)
+     */
+    protected hasValueChangingToNext(fieldPath: string, currentObjectIndex: number): boolean;
+    /**
+     * Check if a field value has changed compared to the previous object
+     */
+    hasValueChangedFromPrevious(fieldPath: string, currentObjectIndex: number): boolean;
+    /**
+     * Check if a field has unequal values across objects
+     */
+    hasUnequalValues(fieldPath: string): boolean;
+    /**
+     * Check if a field has equal values across objects
+     */
+    hasEqualValues(fieldPath: string): boolean;
+    /**
+     * Compare two values for equality (deep comparison for objects/arrays)
+     */
+    private areValuesEqual;
+    /**
+     * Toggle the show only changes filter
+     */
+    toggleShowOnlyChanges(): void;
+    /**
+     * Remove an object from the comparison
+     */
+    removeObject(objectId: string): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCompareViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPCompareViewComponent, "axp-compare-view", never, { "inputs": { "alias": "inputs"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AXPActivityLogComponent, AXPCompareViewComponent, AXPComponentSlot, AXPComponentSlotDirective, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPMenuBadgeHelper, AXPTaskBadgeDirective, AXPTaskBadgeProvider, AXPTaskBadgeService, AXPThemeLayoutActionsComponent, AXPThemeLayoutBlockComponent, AXPThemeLayoutContainerComponent, AXPThemeLayoutEndSideComponent, AXPThemeLayoutFooterComponent, AXPThemeLayoutHeaderComponent, AXPThemeLayoutListComponent, AXPThemeLayoutListItemComponent, AXPThemeLayoutListItemsGroupComponent, AXPThemeLayoutPageHeaderComponent, AXPThemeLayoutPagePrimaryActionsComponent, AXPThemeLayoutPageSecondaryActionsComponent, AXPThemeLayoutSectionComponent, AXPThemeLayoutStartSideComponent, AXPThemeLayoutToolbarComponent, AXPUserAvatarComponent, AXPUserAvatarService, AXP_TASK_BADGE_PROVIDERS, AXP_USER_AVATAR_PROVIDER };
+export type { AXPCompareViewField, AXPCompareViewInputs, AXPCompareViewMode, AXPCompareViewObject, AXPComponentSlotConfig, AXPComponentSlotModuleConfigs, AXPUserAvatarData, AXPUserAvatarProvider, AXPUserAvatarSize, AXPUserAvatarStatus };