@acorex-platform/module-task-management-client 0.0.21

package/fesm2022/acorex-platform-module-task-management-client-acorex-platform-module-task-management-client-CIwafWli.mjs

@@ -0,0 +1,4445 @@
+import { AXPBroadcastEventService, AXPEntityBroadcastService, AXP_MODULE_MANIFEST_PROVIDER, AXP_CATALOG_SCOPE_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/core';
+import * as i1$1 from '@angular/common';
+import { CommonModule, DOCUMENT } from '@angular/common';
+import * as i0 from '@angular/core';
+import { inject, InjectionToken, Injector, DestroyRef, Injectable, computed, input, signal, effect, ViewEncapsulation, ChangeDetectionStrategy, Component, ElementRef, NgModule, output } from '@angular/core';
+import { RootConfig, AXPProjectsWorkPermissionKeys, AXPTaskManagementMenuKeys, AXMTaskBoardSettings, AXPTaskManagementCommandKeys, AXMTaskManagementQueryKeys, TASK_MANAGEMENT_CATALOG_SCOPE_TASKS } from '@acorex-platform/module-task-management-client/contracts';
+import { applyDateFilterPreset, AXPSettingsService, AXPMenuService, AXP_PROTECTED_ROUTE_GUARDS, AXP_HOME_PAGES, AXPSearchCommandProvider, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex-platform/framework-client/common';
+import { AXPSessionService, AXPSessionStatus, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { AXPStateMessageComponent, AXPTaskBadgeProvider, AXP_TASK_BADGE_PROVIDERS } from '@acorex-platform/framework-client/layout/components';
+import { isNil, get, defaultTo } from 'lodash';
+import { AXCalendarService } from '@acorex/core/date-time';
+import { mapCalendarOccasionToHolidayDate, AXMCalendarManagementService, normalizeRegionalCalendarEventIds, AXMCalendarManagementModule } from '@acorex-platform/module-calendar-management-client';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Subject, merge, filter, distinctUntilChanged } from 'rxjs';
+import { AXPPlatformScope, AXPRegionalSetting, AXPSystemStatuses, AXPWidgetsCatalog, AXPWidgetsList } from '@acorex-platform/framework-shared/core';
+import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
+import { AXLocaleService } from '@acorex/core/locale';
+import * as i1 from '@acorex/components/button';
+import { AXButtonModule, AXButtonComponent } from '@acorex/components/button';
+import * as i2 from '@acorex/components/decorators';
+import { AXDecoratorModule, AXDecoratorIconComponent, AXDecoratorGenericComponent } from '@acorex/components/decorators';
+import * as i3 from '@acorex/components/dropdown';
+import { AXDropdownModule } from '@acorex/components/dropdown';
+import * as i5 from '@acorex/core/translation';
+import { AXTranslationModule, AXTranslationService } from '@acorex/core/translation';
+import { AXOverlayService } from '@acorex/cdk/overlay';
+import { AXPlatform } from '@acorex/core/platform';
+import { AXFormatService, AXFormatPipe } from '@acorex/core/format';
+import { AXP_ENTITY_CONFIG_TOKEN, AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
+import { AXPRuntimeModule, provideCommandSetups, provideQuerySetups, AXPCommandEventsService } from '@acorex-platform/framework-client/runtime';
+import { ROUTES, RouterLink } from '@angular/router';
+import { AXPLayoutBaseWidgetComponent, AXPWidgetCoreModule, AXP_WIDGET_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/layout/widget-core';
+import { cloneProperty, AXPWidgetGroupEnum } from '@acorex-platform/framework-shared/widget-core';
+import { AXP_APPEARANCE_PROPERTY_GROUP, AXP_DATA_PATH_PROPERTY } from '@acorex-platform/framework-client/layout/widgets';
+import { defineDashboardWidgetDimensions, layoutFromDimensions } from '@acorex-platform/module-dashboard-management-client';
+import { AXChipsComponent } from '@acorex/components/chips';
+import { AXPCommonPermissionGroupKeys, AXPCommonMenuKeys } from '@acorex-platform/module-common-client/contracts';
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Task Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const TaskManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    type: 'domain',
+    domain: 'operations',
+    // Module dependencies (optional)
+};
+//#endregion
+
+function toTaskBoardHolidayDate(occasion) {
+    return mapCalendarOccasionToHolidayDate(occasion);
+}
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Constants -----
+/** Persisted task rows shown on the task board. */
+const TASK_BOARD_TASK_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.task.name}`;
+/** Assignment rows that change who a task is assigned to. */
+const TASK_BOARD_TASK_ASSIGNMENT_ENTITY = `${RootConfig.module.name}.${RootConfig.entities.taskAssignment.name}`;
+/**
+ * Workflow human-task cards come from suspended instance bookmarks, not Task rows.
+ * Keep this string in sync with `WorkflowManagement.WorkflowInstance` (do not import workflow-management — it already depends on this package).
+ */
+const TASK_BOARD_WORKFLOW_INSTANCE_ENTITY = 'WorkflowManagement.WorkflowInstance';
+const TASK_BOARD_REALTIME_ENTITIES = new Set([
+    TASK_BOARD_TASK_ENTITY,
+    TASK_BOARD_TASK_ASSIGNMENT_ENTITY,
+    TASK_BOARD_WORKFLOW_INSTANCE_ENTITY,
+]);
+//#endregion
+//#region ----- Helpers -----
+/** True when a layout-refresh / entity-mutation name should refresh the task board or its menu badge. */
+function isTaskBoardRealtimeEntity(name) {
+    return name != null && TASK_BOARD_REALTIME_ENTITIES.has(name);
+}
+//#endregion
+
+function serializeDate(value) {
+    if (!value) {
+        return null;
+    }
+    return new Date(value).toISOString();
+}
+/** Stable cache key for {@link AXPTaskBoardService.getTasks} deduplication. */
+function serializeTaskFilterForCache(options) {
+    if (!options) {
+        return '{}';
+    }
+    const normalized = {
+        types: options.types?.slice().sort(),
+        assigneeIds: options.assigneeIds?.map(String).sort(),
+        reporterIds: options.reporterIds?.map(String).sort(),
+        tags: options.tags?.slice().sort(),
+        priorities: options.priorities?.slice().sort(),
+        dueStatusKeys: options.dueStatusKeys?.slice().sort(),
+        subjectRefTypes: options.subjectRefTypes?.slice().sort(),
+        subjectRefIds: options.subjectRefIds?.map(String).sort(),
+        skip: options.skip ?? 0,
+        take: options.take ?? null,
+        range: options.range
+            ? {
+                from: serializeDate(options.range.from),
+                end: serializeDate(options.range.end),
+            }
+            : null,
+    };
+    return JSON.stringify(normalized);
+}
+
+/**
+ * An abstract class for a workflow task provider, which is responsible for
+ * fetching and manipulating task data from a specific source.
+ * @template T - The type of custom data associated with the tasks.
+ */
+class AXPWorkflowTaskProvider {
+    constructor() {
+        this.eventService = inject(AXPBroadcastEventService);
+    }
+    async getResources() {
+        return [];
+    }
+    refresh() {
+        this.eventService.publish('task-board.refresh', {
+            provider: this.name,
+        });
+    }
+    close() {
+        this.eventService.publish('task-board.close', {
+            provider: this.name,
+        });
+    }
+    /**
+     * Opens a task on the task board (after refresh, the board selects this task).
+     */
+    requestTaskBoardOpenTask(task) {
+        this.eventService.publish('task-board.open-task', {
+            provider: this.name,
+            task: { ...task, provider: this.name },
+        });
+    }
+}
+/**
+ * Interface that task popover components must implement.
+ * Components provided by task providers should implement this interface to receive the task data.
+ */
+class AXPTaskPopoverComponent {
+    constructor() {
+        this.eventService = inject(AXPBroadcastEventService);
+    }
+    /**
+     * Requests the task board to refresh popover/task data.
+     * Provider defaults to the current task provider.
+     */
+    refreshPopover(provider) {
+        this.eventService.publish('task-board.refresh', {
+            provider: provider ?? this.task()?.provider,
+        });
+    }
+    /**
+     * Requests the host task board view to close the active popover.
+     * Provider defaults to the current task provider.
+     */
+    closePopover(provider) {
+        this.eventService.publish('task-board.close', {
+            provider: provider ?? this.task()?.provider,
+        });
+    }
+}
+/**
+ * Optional resolver registered by workflow-management to discover task providers on demand.
+ */
+const AXP_WORKFLOW_TASK_PROVIDER_RESOLVER = new InjectionToken('AXP_WORKFLOW_TASK_PROVIDER_RESOLVER');
+/**
+ * Injection token for registering multiple workflow task providers.
+ */
+const AXP_WORKFLOW_TASK_PROVIDER = new InjectionToken('AXP_WORKFLOW_TASK_PROVIDER');
+
+class AXPTaskBoardService {
+    constructor() {
+        this.calendarService = inject(AXCalendarService);
+        this.calendarManagementService = inject(AXMCalendarManagementService);
+        this.injector = inject(Injector);
+        this.providerResolver = inject(AXP_WORKFLOW_TASK_PROVIDER_RESOLVER, { optional: true });
+        this.destroyRef = inject(DestroyRef);
+        this.eventService = inject(AXPBroadcastEventService);
+        this.entityEvents = inject(AXPEntityBroadcastService);
+        /** Cached resolved providers; set after first call to resolveProviders(). */
+        this.resolvedProviders = null;
+        /** Cached resolved provider metadata; set together with {@link resolvedProviders}. */
+        this.resolvedTaskTypeOptions = null;
+        this.taskResultCache = new Map();
+        this.taskResultInFlight = new Map();
+        this.taskCacheTtlMs = 5_000;
+        this.calendarEventTypesCache = null;
+        this.calendarEventTypesInFlight = null;
+        this.refresh$ = new Subject();
+        this.close$ = new Subject();
+        this.openTask$ = new Subject();
+        this.refresh$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
+            this.resolvedProviders = null;
+            this.resolvedTaskTypeOptions = null;
+            this.invalidateTaskCache();
+        });
+        //
+        this.eventService
+            .listen('task-board.refresh')
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(({ data }) => {
+            this.refresh$.next(data ?? {});
+        });
+        this.eventService
+            .listen('task-board.close')
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(({ data }) => {
+            this.close$.next(data ?? {});
+        });
+        this.eventService
+            .listen('task-board.open-task')
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(({ data }) => {
+            if (data?.task || (data?.instanceId && data?.activityId)) {
+                this.openTask$.next(data);
+            }
+        });
+        // Keep board in sync when Task / assignment / workflow-instance rows change elsewhere
+        // (local CRUD + realtime `entity.mutation` → layout refresh). Refresh all providers:
+        // site-inspection cards also come from workflow human-task bookmarks, not only Task rows.
+        merge(this.entityEvents.listenDeleted(), this.entityEvents.listenCreated(), this.entityEvents.listenModified(), this.entityEvents.listenLayoutRefresh())
+            .pipe(filter(({ data }) => isTaskBoardRealtimeEntity(data?.name)), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            this.requestRefresh();
+        });
+    }
+    /**
+     * Requests task board refresh through broadcast events.
+     */
+    requestRefresh(provider) {
+        this.eventService.publish('task-board.refresh', { provider });
+    }
+    /**
+     * Requests active task popover close through broadcast events.
+     */
+    requestClose(provider) {
+        this.eventService.publish('task-board.close', { provider });
+    }
+    /**
+     * Opens a task on the task board (refresh, then select the task in the active view).
+     */
+    requestOpenTask(taskOrRef, provider) {
+        if ('id' in taskOrRef && taskOrRef.title !== undefined) {
+            const task = taskOrRef;
+            this.eventService.publish('task-board.open-task', { provider: provider ?? task.provider, task });
+            return;
+        }
+        const ref = taskOrRef;
+        this.eventService.publish('task-board.open-task', ref);
+    }
+    /** Clears cached workflow task providers so the next resolve re-reads DI registrations. */
+    clearProviderCache() {
+        this.resolvedProviders = null;
+        this.resolvedTaskTypeOptions = null;
+    }
+    /** Clears cached task query results and calendar metadata. */
+    invalidateTaskCache() {
+        this.taskResultCache.clear();
+        this.taskResultInFlight.clear();
+        this.calendarEventTypesCache = null;
+        this.calendarEventTypesInFlight = null;
+        this.eventService.publish('task-board.invalidate-task-cache', {});
+    }
+    /**
+     * Resolves workflow task providers. Uses the optional workflow resolver when registered so discovery
+     * can be re-run after workflow definitions become available (first app load before mock seed).
+     */
+    async resolveProviders(options) {
+        if (!options?.force &&
+            this.resolvedProviders !== null &&
+            this.resolvedProviders.length > 0) {
+            return this.resolvedProviders;
+        }
+        let providers = [];
+        if (this.providerResolver) {
+            providers = await this.providerResolver(options);
+            if (providers.length === 0) {
+                providers = await this.providerResolver({ ...options, force: true });
+            }
+        }
+        else {
+            providers = await this.flattenProviderEntries(this.getInjectedProviderEntries());
+        }
+        if (providers.length > 0) {
+            this.resolvedProviders = providers;
+            this.resolvedTaskTypeOptions = await this.resolveTaskTypeOptions(providers);
+        }
+        else {
+            this.resolvedProviders = null;
+            this.resolvedTaskTypeOptions = null;
+        }
+        return providers;
+    }
+    async resolveTaskTypeOptions(providers) {
+        return Promise.all(providers.map(async (provider) => ({
+            name: provider.name,
+            title: await provider.getTitle(),
+            icon: await provider.getIcon(),
+        })));
+    }
+    getInjectedProviderEntries() {
+        const injected = this.injector.get(AXP_WORKFLOW_TASK_PROVIDER, null, { optional: true });
+        if (injected == null) {
+            return [];
+        }
+        return Array.isArray(injected) ? injected : [injected];
+    }
+    async flattenProviderEntries(entries) {
+        const resolved = await Promise.all(entries.map((entry) => Promise.resolve(entry)));
+        const flattened = resolved.flatMap((entry) => (Array.isArray(entry) ? entry : [entry]));
+        return flattened.filter((provider) => provider != null && typeof provider.getTasks === 'function');
+    }
+    async getTaskTypes(options) {
+        return this.resolveProviders(options);
+    }
+    /**
+     * Resolved provider metadata for UI filters and datasources.
+     * Call {@link resolveProviders} or {@link getTaskTypes} first.
+     */
+    getTaskTypeOptions() {
+        return this.resolvedTaskTypeOptions ?? [];
+    }
+    getTaskTypeOption(name) {
+        if (!name) {
+            return null;
+        }
+        return this.resolvedTaskTypeOptions?.find((option) => option.name === name) ?? null;
+    }
+    async getTasks(options) {
+        const cacheKey = serializeTaskFilterForCache(options);
+        const now = Date.now();
+        const cached = this.taskResultCache.get(cacheKey);
+        if (cached && cached.expiresAt > now) {
+            return cached.result;
+        }
+        const inFlight = this.taskResultInFlight.get(cacheKey);
+        if (inFlight) {
+            return inFlight;
+        }
+        const request = this.fetchTasksFromProviders(options)
+            .then((result) => {
+            this.taskResultCache.set(cacheKey, {
+                result,
+                expiresAt: Date.now() + this.taskCacheTtlMs,
+            });
+            return result;
+        })
+            .finally(() => {
+            this.taskResultInFlight.delete(cacheKey);
+        });
+        this.taskResultInFlight.set(cacheKey, request);
+        return request;
+    }
+    async fetchTasksFromProviders(options) {
+        const providers = await this.resolveProviders();
+        if (providers.length === 0) {
+            console.warn('No task providers available');
+            return { items: [], total: 0 };
+        }
+        const filteredProviders = providers.filter((provider) => (options?.types?.length ?? 0) === 0 || options?.types?.includes(provider.name));
+        if (filteredProviders.length === 0) {
+            return { items: [], total: 0 };
+        }
+        // Single provider case - handles pagination efficiently at the source.
+        if (filteredProviders.length === 1) {
+            const provider = filteredProviders[0];
+            const result = await provider.getTasks(options);
+            // Add provider name to each task for identification.
+            const itemsWithProvider = result.items.map((t) => ({ ...t, provider: provider.name }));
+            return { items: itemsWithProvider, total: result.total };
+        }
+        // Multi-provider case - fetch filtered data then paginate client-side.
+        const mergeData = [];
+        // Separate pagination from filtering to pass correct options to providers.
+        const { skip, take, ...providerOptions } = options ?? {};
+        const listTake = options?.take != null && options.take > 0 ? options.take : 5000;
+        const promises = filteredProviders.map((provider) => provider
+            .getTasks({ ...providerOptions, skip: 0, take: listTake })
+            .then((result) => result.items.map((t) => ({ ...t, provider: provider.name }))));
+        const results = await Promise.all(promises);
+        for (const resultArray of results) {
+            mergeData.push(...resultArray);
+        }
+        // Apply pagination client-side after merging the correctly filtered data.
+        const total = mergeData.length;
+        const finalSkip = skip ?? 0;
+        const finalTake = take ?? total;
+        const items = mergeData.slice(finalSkip, finalSkip + finalTake);
+        return { items, total };
+    }
+    async updateTaskDateRange(task, range) {
+        const providers = await this.resolveProviders();
+        const provider = providers.find((p) => p.name === task.provider) ?? null;
+        if (!provider) {
+            throw new Error(`Task provider '${task.provider}' not found`);
+        }
+        // Create a task update object and call the unified method
+        const taskWithNewRange = { ...task, startDate: range.from, endDate: range.end };
+        const updatedTasks = await provider.updateTasks([taskWithNewRange]);
+        if (updatedTasks.length > 0) {
+            return updatedTasks[0];
+        }
+        else {
+            throw new Error('Task update failed or task not found in provider.');
+        }
+    }
+    async updateTasks(tasks) {
+        if (!tasks || tasks.length === 0) {
+            return [];
+        }
+        // Ensure all tasks are from the same provider before performing a bulk update
+        if (!tasks.every((t) => t.provider === tasks[0].provider)) {
+            throw new Error('All tasks must have the same provider for a bulk update.');
+        }
+        const providers = await this.resolveProviders();
+        const provider = providers.find((p) => p.name === tasks[0].provider) ?? null;
+        if (!provider) {
+            throw new Error(`Task provider '${tasks[0].provider}' not found`);
+        }
+        return provider.updateTasks(tasks);
+    }
+    async executeCommand(command, providerName) {
+        const providers = await this.resolveProviders();
+        const provider = providers.find((p) => p.name === providerName) ?? null;
+        if (!provider) {
+            throw new Error(`Task provider '${providerName}' not found`);
+        }
+        return await provider.executeCommand(command);
+    }
+    async getStatusName(key, providerName) {
+        const providers = await this.resolveProviders();
+        const provider = providers.find((p) => p.name === providerName) ?? null;
+        if (!provider) {
+            throw new Error(`Task provider '${providerName}' not found`);
+        }
+        const statuses = await provider.getStatuses();
+        return statuses.find((s) => s.key === key)?.title ?? null;
+    }
+    async getEvents(range, eventTypeIds) {
+        const events = await this.calendarManagementService.getOccasions(range, eventTypeIds);
+        return events.map((event) => toTaskBoardHolidayDate(event));
+    }
+    async getCalendarEventTypes() {
+        if (this.calendarEventTypesCache) {
+            return this.calendarEventTypesCache;
+        }
+        if (this.calendarEventTypesInFlight) {
+            return this.calendarEventTypesInFlight;
+        }
+        this.calendarEventTypesInFlight = this.calendarManagementService
+            .getCalendars()
+            .then((result) => {
+            this.calendarEventTypesCache = result ?? [];
+            return this.calendarEventTypesCache;
+        })
+            .catch((error) => {
+            console.error(error);
+            this.calendarEventTypesCache = [];
+            return this.calendarEventTypesCache;
+        })
+            .finally(() => {
+            this.calendarEventTypesInFlight = null;
+        });
+        return this.calendarEventTypesInFlight;
+    }
+    /**
+     * Returns the provider by name. Uses cached resolved providers; returns null if not resolved yet.
+     * Ensure resolveProviders() has been called (e.g. via getTaskTypes() or getTasks()) before using this.
+     */
+    getProvider(name) {
+        if (!name)
+            return null;
+        return this.resolvedProviders?.find((p) => p.name === name) ?? null;
+    }
+    rangeCalculator(type) {
+        switch (type) {
+            case 'today':
+                return {
+                    from: this.calendarService.create(new Date()).startOf('day').date,
+                    end: this.calendarService.create(new Date()).endOf('day').date,
+                };
+            case 'this-week':
+                return {
+                    from: this.calendarService.create(new Date()).startOf('week').date,
+                    end: this.calendarService.create(new Date()).endOf('week').date,
+                };
+            case 'this-month':
+                return {
+                    from: this.calendarService.create(new Date()).startOf('month').date,
+                    end: this.calendarService.create(new Date()).endOf('month').date,
+                };
+            default:
+                return undefined;
+        }
+    }
+    async getResources(providerName) {
+        const providers = await this.resolveProviders();
+        const provider = providers.find((p) => p.name === providerName) ?? null;
+        if (!provider) {
+            throw new Error(`Task provider '${providerName}' not found`);
+        }
+        return provider.getResources();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Constants   ----
+/** Sentinel id for the task-board assignee filter option: tasks with no assignee. */
+const AXM_TASK_BOARD_UNASSIGNED_ASSIGNEE_ID = 'TaskManagement:TaskBoard:Assignee:Unassigned';
+//#endregion
+//#region ----   Permission Helpers   ----
+/** Permission to view and filter tasks across all assignees on the task board. */
+const AXM_TASK_VIEW_ALL_PERMISSION = AXPProjectsWorkPermissionKeys.ViewAllTasks;
+/**
+ * Returns whether the current session may filter tasks by any assignee.
+ */
+function canViewAllTaskAssignees(sessionService) {
+    return sessionService.authorize(AXM_TASK_VIEW_ALL_PERMISSION);
+}
+function isTaskBoardUnassignedAssigneeId(id) {
+    return String(id) === AXM_TASK_BOARD_UNASSIGNED_ASSIGNEE_ID;
+}
+/** Whether the user has a persisted assignee filter (including an explicit empty selection). */
+function hasTaskBoardSavedAssigneePreference(savedAssigneeIds) {
+    return savedAssigneeIds !== undefined && savedAssigneeIds !== null;
+}
+/**
+ * Resolves saved assignee ids from settings. When the setting is unset (`undefined`/`null`):
+ * - Users with view-all permission default to no assignee filter (all tasks).
+ * - Everyone else defaults to the signed-in user only.
+ * An explicit empty array means "no assignee filter" only for view-all users;
+ * for everyone else it is coerced to the signed-in user.
+ */
+function resolveTaskBoardSavedAssigneeIds(sessionService, savedAssigneeIds) {
+    if (hasTaskBoardSavedAssigneePreference(savedAssigneeIds)) {
+        const saved = savedAssigneeIds ?? [];
+        if (saved.length === 0 && !canViewAllTaskAssignees(sessionService)) {
+            const currentUserId = sessionService.user?.id;
+            return currentUserId != null ? [currentUserId] : [];
+        }
+        return saved;
+    }
+    if (canViewAllTaskAssignees(sessionService)) {
+        return [];
+    }
+    const currentUserId = sessionService.user?.id;
+    return currentUserId != null ? [currentUserId] : [];
+}
+/** Assignee picker item for the signed-in user (used by task-board assignee datasource). */
+function resolveTaskBoardCurrentUserAssigneeItem(sessionService) {
+    const currentUser = sessionService.user;
+    if (currentUser?.id == null) {
+        return null;
+    }
+    return {
+        id: currentUser.id,
+        displayName: currentUser.title || currentUser.name,
+        username: currentUser.name,
+    };
+}
+/**
+ * Restricts assignee filter ids to the current user when {@link canViewAllTaskAssignees} is false.
+ * Strips the unassigned sentinel for users without view-all permission.
+ * Empty selection is only allowed for view-all users (means all assignees).
+ */
+function normalizeTaskBoardAssigneeIds(sessionService, assigneeIds) {
+    if (canViewAllTaskAssignees(sessionService)) {
+        return assigneeIds;
+    }
+    const currentUserId = sessionService.user?.id;
+    return currentUserId != null ? [currentUserId] : [];
+}
+/**
+ * Whether a task matches the selected assignee filter ids (OR semantics).
+ * Supports {@link AXM_TASK_BOARD_UNASSIGNED_ASSIGNEE_ID} for tasks without an assignee.
+ */
+function matchesTaskBoardAssigneeFilter(assigneeId, filterIds) {
+    if (filterIds.length === 0) {
+        return true;
+    }
+    const filterSet = new Set(filterIds.map(String));
+    const wantsUnassigned = filterSet.has(AXM_TASK_BOARD_UNASSIGNED_ASSIGNEE_ID);
+    const hasAssignee = assigneeId != null && assigneeId !== '';
+    if (!hasAssignee) {
+        return wantsUnassigned;
+    }
+    return filterSet.has(String(assigneeId));
+}
+/**
+ * Whether a workflow task matches assignee filters using assigned/candidate user ids.
+ */
+function matchesTaskBoardAssigneeUserIdsFilter(userIds, filterIds) {
+    if (filterIds.length === 0) {
+        return true;
+    }
+    const filterSet = new Set(filterIds.map(String));
+    const wantsUnassigned = filterSet.has(AXM_TASK_BOARD_UNASSIGNED_ASSIGNEE_ID);
+    if (userIds.length === 0) {
+        return wantsUnassigned;
+    }
+    return userIds.some((id) => filterSet.has(String(id)));
+}
+//#endregion
+
+//#region ---- Imports ----
+const AXM_TASK_BOARD_VIEW_CATEGORIES = [
+    'calendar',
+    'timeline',
+    'table',
+    'kanban',
+];
+const AXM_TASK_BOARD_DEFAULT_LAYOUT_BY_CATEGORY = {
+    calendar: 'monthly',
+    timeline: 'daily',
+    table: 'simple',
+    kanban: null,
+};
+//#endregion
+//#region ---- Category ↔ Leaf Mode ----
+const CALENDAR_LAYOUT_TO_MODE = {
+    daily: 'day',
+    weekly: 'week',
+    monthly: 'month',
+    agenda: 'agenda',
+};
+const TIMELINE_LAYOUT_TO_MODE = {
+    daily: 'timeline-day',
+    weekly: 'timeline-weekly',
+    monthly: 'timeline-month',
+    yearly: 'timeline-year',
+};
+const TABLE_LAYOUT_TO_MODE = {
+    simple: 'grid',
+    grouped: 'status-grouped-grid',
+};
+function resolveTaskBoardViewCategory(viewMode) {
+    if (viewMode === 'kanban') {
+        return 'kanban';
+    }
+    if (viewMode === 'grid' || viewMode === 'status-grouped-grid') {
+        return 'table';
+    }
+    if (viewMode.startsWith('timeline-')) {
+        return 'timeline';
+    }
+    return 'calendar';
+}
+function resolveTaskBoardViewLayout(viewMode) {
+    if (viewMode === 'kanban') {
+        return null;
+    }
+    const calendarEntry = Object.entries(CALENDAR_LAYOUT_TO_MODE).find(([, mode]) => mode === viewMode);
+    if (calendarEntry) {
+        return calendarEntry[0];
+    }
+    const timelineEntry = Object.entries(TIMELINE_LAYOUT_TO_MODE).find(([, mode]) => mode === viewMode);
+    if (timelineEntry) {
+        return timelineEntry[0];
+    }
+    const tableEntry = Object.entries(TABLE_LAYOUT_TO_MODE).find(([, mode]) => mode === viewMode);
+    if (tableEntry) {
+        return tableEntry[0];
+    }
+    return AXM_TASK_BOARD_DEFAULT_LAYOUT_BY_CATEGORY.calendar;
+}
+function resolveTaskBoardLeafViewMode(category, layout) {
+    switch (category) {
+        case 'calendar':
+            return CALENDAR_LAYOUT_TO_MODE[layout ?? 'monthly'] ?? 'month';
+        case 'timeline':
+            return TIMELINE_LAYOUT_TO_MODE[layout ?? 'daily'] ?? 'timeline-day';
+        case 'table':
+            return TABLE_LAYOUT_TO_MODE[layout ?? 'simple'] ?? 'grid';
+        case 'kanban':
+            return 'kanban';
+        default:
+            return 'month';
+    }
+}
+function isTaskBoardRangeFilterCategory(category) {
+    return category === 'table' || category === 'kanban';
+}
+function usesTaskBoardToolbarNavigator(_viewMode) {
+    return true;
+}
+function getTaskBoardLayoutOptions(category) {
+    switch (category) {
+        case 'calendar':
+            return [
+                { key: 'daily', text: 'daily', icon: 'fa-light fa-calendar-day' },
+                { key: 'weekly', text: 'weekly', icon: 'fa-light fa-calendar-week' },
+                { key: 'monthly', text: 'monthly', icon: 'fa-light fa-calendar-alt' },
+                { key: 'agenda', text: 'agenda', icon: 'fa-light fa-calendar-range' },
+            ];
+        case 'timeline':
+            return [
+                { key: 'daily', text: 'daily', icon: 'fa-light fa-calendar-day' },
+                { key: 'weekly', text: 'weekly', icon: 'fa-light fa-calendar-week' },
+                { key: 'monthly', text: 'monthly', icon: 'fa-light fa-calendar-alt' },
+                { key: 'yearly', text: 'yearly', icon: 'fa-light fa-calendar-range' },
+            ];
+        case 'table':
+            return [
+                { key: 'simple', text: 'grid', icon: 'fa-light fa-table' },
+                { key: 'grouped', text: 'status-grouped-grid', icon: 'fa-light fa-table' },
+            ];
+        default:
+            return [];
+    }
+}
+function deriveTaskBoardDateRangeFromNavigator(calendarService, viewMode, currentDate, daysCount) {
+    const cal = calendarService.create(currentDate);
+    switch (viewMode) {
+        case 'month':
+        case 'timeline-month':
+            return {
+                from: cal.startOf('month').date,
+                end: cal.endOf('month').date,
+            };
+        case 'week':
+            return {
+                from: cal.startOf('week').date,
+                end: cal.add('day', 6).date,
+            };
+        case 'timeline-weekly':
+            return {
+                from: cal.date,
+                end: cal.add('day', Math.max(1, daysCount) - 1).date,
+            };
+        case 'timeline-year':
+            return {
+                from: cal.startOf('year').date,
+                end: cal.endOf('year').date,
+            };
+        case 'agenda':
+        case 'grid':
+        case 'status-grouped-grid':
+        case 'kanban':
+            return {
+                from: cal.date,
+                end: cal.add('day', Math.max(1, daysCount) - 1).date,
+            };
+        case 'day':
+        case 'timeline-day':
+        default:
+            return {
+                from: cal.startOf('day').date,
+                end: cal.endOf('day').date,
+            };
+    }
+}
+function createTodayTaskBoardDateFilterValue(calendarService) {
+    return applyDateFilterPreset('today', calendarService) ?? {
+        operation: { type: 'between' },
+        value: {
+            from: calendarService.create(new Date()).startOf('day').date.toISOString(),
+            to: calendarService.create(new Date()).endOf('day').date.toISOString(),
+        },
+    };
+}
+function parseTaskBoardDateFilterValue(value) {
+    if (value == null) {
+        return null;
+    }
+    const raw = value;
+    const payload = raw.value;
+    if (payload == null) {
+        return null;
+    }
+    if (typeof payload === 'string') {
+        const date = new Date(payload);
+        return Number.isNaN(date.getTime()) ? null : { from: date, end: date };
+    }
+    const from = payload.from ? new Date(payload.from) : null;
+    const end = payload.to ? new Date(payload.to) : from;
+    if (!from || !end || Number.isNaN(from.getTime()) || Number.isNaN(end.getTime())) {
+        return null;
+    }
+    return { from, end };
+}
+function toTaskBoardDateFilterValue(range) {
+    return {
+        operation: { type: 'between' },
+        value: {
+            from: range.from.toISOString(),
+            to: range.end.toISOString(),
+        },
+    };
+}
+async function formatTaskBoardDateRangeDisplayText(range, calendarService, format) {
+    const from = calendarService.create(range.from).format(format);
+    const end = calendarService.create(range.end).format(format);
+    if (from === end) {
+        return from;
+    }
+    return `${from} – ${end}`;
+}
+function applyTaskBoardDateRangeToViewModel(range, setCurrentDate, setDaysCount) {
+    setCurrentDate(range.from);
+    const start = new Date(range.from.getFullYear(), range.from.getMonth(), range.from.getDate());
+    const end = new Date(range.end.getFullYear(), range.end.getMonth(), range.end.getDate());
+    const days = Math.round((end.getTime() - start.getTime()) / (1000 * 3600 * 24)) + 1;
+    setDaysCount(Math.max(1, days));
+}
+//#endregion
+//#region ---- Settings Visibility ----
+function normalizeVisibleTaskBoardCategories(flags) {
+    const categories = [];
+    if (flags.calendar !== false) {
+        categories.push('calendar');
+    }
+    if (flags.timeline !== false) {
+        categories.push('timeline');
+    }
+    if (flags.table !== false) {
+        categories.push('table');
+    }
+    if (flags.kanban !== false) {
+        categories.push('kanban');
+    }
+    return categories.length > 0 ? categories : [...AXM_TASK_BOARD_VIEW_CATEGORIES];
+}
+function resolveTaskBoardCategoryLayoutFromQuery(category, layout) {
+    if (category === 'kanban') {
+        return null;
+    }
+    const options = getTaskBoardLayoutOptions(category);
+    const match = options.find((option) => option.key === layout);
+    return (match?.key ?? AXM_TASK_BOARD_DEFAULT_LAYOUT_BY_CATEGORY[category]);
+}
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Menu Path -----
+/**
+ * Builds the task-board menu / navigate path including persisted view + layout query params.
+ * Example: `safetyminder/TaskManagement/task-board?view=calendar&layout=monthly`
+ */
+function buildTaskBoardMenuPath(applicationName, moduleName, viewMode, layouts = {}) {
+    const effectiveMode = (viewMode || 'month');
+    const category = resolveTaskBoardViewCategory(effectiveMode);
+    const layout = resolveTaskBoardMenuLayout(category, effectiveMode, layouts);
+    const base = `${applicationName}/${moduleName}/task-board`;
+    const params = new URLSearchParams({ view: category });
+    if (layout) {
+        params.set('layout', layout);
+    }
+    return `${base}?${params.toString()}`;
+}
+function resolveTaskBoardMenuLayout(category, viewMode, layouts) {
+    switch (category) {
+        case 'calendar':
+            return (layouts.calendar ??
+                resolveTaskBoardViewLayout(viewMode) ??
+                AXM_TASK_BOARD_DEFAULT_LAYOUT_BY_CATEGORY.calendar);
+        case 'timeline':
+            return (layouts.timeline ??
+                resolveTaskBoardViewLayout(viewMode) ??
+                AXM_TASK_BOARD_DEFAULT_LAYOUT_BY_CATEGORY.timeline);
+        case 'table':
+            return (layouts.table ??
+                resolveTaskBoardViewLayout(viewMode) ??
+                AXM_TASK_BOARD_DEFAULT_LAYOUT_BY_CATEGORY.table);
+        case 'kanban':
+            return null;
+        default:
+            return AXM_TASK_BOARD_DEFAULT_LAYOUT_BY_CATEGORY.calendar;
+    }
+}
+//#endregion
+
+const AXPTASK_PRIORITIES = ['urgent', 'high', 'normal', 'low'];
+const TASK_PRIORITY_ORDER = {
+    urgent: 0,
+    high: 1,
+    normal: 2,
+    low: 3,
+    no_priority: 4,
+};
+/** Normalizes workflow or legacy task-board priority values to the canonical enum. */
+function normalizeTaskPriority(value) {
+    const normalized = String(value ?? 'normal')
+        .trim()
+        .toLowerCase();
+    if (normalized === 'urgent' || normalized === 'high' || normalized === 'normal' || normalized === 'low') {
+        return normalized;
+    }
+    const legacyMap = {
+        highest: 'urgent',
+        medium: 'normal',
+        lowest: 'low',
+    };
+    return legacyMap[normalized] ?? 'normal';
+}
+function getTaskPriorityColor(priority) {
+    switch (priority) {
+        case 'urgent':
+            return 'danger';
+        case 'high':
+            return 'warning';
+        case 'normal':
+            return 'secondary';
+        case 'low':
+            return 'neutral';
+    }
+}
+const LEGACY_PRIORITY_FILTER_MAP = {
+    highest: 'urgent',
+    medium: 'normal',
+    lowest: 'low',
+};
+/** Maps persisted or query-string priority filter keys to the canonical filter enum. */
+function normalizePriorityFilterKey(value) {
+    const normalized = String(value ?? '')
+        .trim()
+        .toLowerCase();
+    if (normalized === 'no_priority') {
+        return 'no_priority';
+    }
+    if (normalized in LEGACY_PRIORITY_FILTER_MAP) {
+        return LEGACY_PRIORITY_FILTER_MAP[normalized];
+    }
+    return normalizeTaskPriority(normalized);
+}
+function normalizePriorityFilterKeys(values) {
+    if (!values?.length) {
+        return [];
+    }
+    return [...new Set(values.map(normalizePriorityFilterKey))];
+}
+function getTaskPriorityFilterKey(task) {
+    return task.priority ? normalizeTaskPriority(task.priority) : 'no_priority';
+}
+function matchesTaskPriorityFilter(task, priorities) {
+    if (priorities.length === 0) {
+        return true;
+    }
+    const filterSet = new Set(priorities.map(normalizePriorityFilterKey));
+    return filterSet.has(getTaskPriorityFilterKey(task));
+}
+
+/**
+ * Keeps task-type filter values on stable provider {@link AXPTaskBoardTaskTypeOption.name} keys.
+ * Display titles are locale-dependent and must never be used for filtering.
+ */
+function normalizeTaskTypeFilterNames(values, taskTypes) {
+    if (!values?.length) {
+        return [];
+    }
+    if (taskTypes.length === 0) {
+        return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+    }
+    const names = new Set(taskTypes.map((type) => type.name));
+    const normalized = values.flatMap((value) => {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return [];
+        }
+        if (names.has(trimmed)) {
+            return [trimmed];
+        }
+        const matchedByTitle = taskTypes.find((type) => type.title.trim() === trimmed);
+        if (matchedByTitle) {
+            return [matchedByTitle.name];
+        }
+        return [];
+    });
+    return [...new Set(normalized)];
+}
+const DUE_STATUS_FILTER_NAMES = new Set([
+    'completed',
+    'no-due-date',
+    'overdue',
+    'due-today',
+    'due-tomorrow',
+    'due-this-week',
+    'upcoming',
+]);
+/** Maps due-status filter chips back to stable keys (never localized labels). */
+function normalizeDueStatusFilterKeys(values) {
+    if (!values?.length) {
+        return [];
+    }
+    const titleToName = {
+        completed: 'completed',
+        'no due date': 'no-due-date',
+        overdue: 'overdue',
+        'due today': 'due-today',
+        'due tomorrow': 'due-tomorrow',
+        'due this week': 'due-this-week',
+        upcoming: 'upcoming',
+    };
+    const normalized = values.flatMap((value) => {
+        const trimmed = String(value ?? '').trim();
+        if (!trimmed) {
+            return [];
+        }
+        if (DUE_STATUS_FILTER_NAMES.has(trimmed)) {
+            return [trimmed];
+        }
+        const fromTitle = titleToName[trimmed.toLowerCase()];
+        return fromTitle ? [fromTitle] : [];
+    });
+    return [...new Set(normalized)];
+}
+/** Re-exports priority normalization for filter panels that may receive display labels. */
+function normalizeTaskBoardPriorityFilterKeys(values) {
+    return normalizePriorityFilterKeys(values);
+}
+
+const AXMTaskBoardViewModel = signalStore({ providedIn: 'root' }, withState(() => ({
+    daysCount: 7,
+    taskTypes: [],
+    taskTypeOptions: [],
+    isLoading: true,
+    detailPanel: false,
+    selectedTask: null,
+    rangeStartDate: null,
+    currentDate: new Date(),
+    currentViewMode: 'month',
+    visibleViewCategories: ['calendar', 'timeline', 'table', 'kanban'],
+    calendarLayout: 'monthly',
+    timelineLayout: 'daily',
+    tableLayout: 'simple',
+    selectedTaskTypeNames: [],
+    selectedAssigneeIds: [],
+    assigneeFilterHasSavedPreference: false,
+    selectedPriorities: [],
+    selectedDueStatusKeys: [],
+    colorBy: 'dueDate',
+    selectedReporterIds: [],
+    selectedCalendarEventTypeIds: [],
+})), withComputed((store) => ({
+    currentViewCategory: computed(() => resolveTaskBoardViewCategory(store.currentViewMode())),
+    selectedTaskTypes: computed(() => {
+        const names = store.selectedTaskTypeNames();
+        if (!names || names.length === 0) {
+            return [];
+        }
+        return store.taskTypes().filter((tt) => names.includes(tt.name));
+    }),
+    isTaskSelected: computed(() => store.selectedTask() !== null),
+    isDetailPanelOpen: computed(() => store.detailPanel()),
+    effectiveColorBy: computed(() => store.colorBy()),
+    endDate: computed(() => {
+        const currentDate = store.currentDate();
+        const daysCount = store.daysCount();
+        // Calculate end of the last day in the range (23:59:59.999)
+        const endDate = new Date(currentDate);
+        endDate.setDate(endDate.getDate() + daysCount - 1);
+        endDate.setHours(23, 59, 59, 999);
+        return endDate;
+    }),
+    activeFilterCount: computed(() => {
+        let count = 0;
+        if (store.currentViewMode() !== 'kanban' &&
+            store.currentViewMode() !== 'status-grouped-grid' &&
+            store.selectedTaskTypeNames().length > 0) {
+            count++;
+        }
+        if (store.selectedAssigneeIds().length > 0) {
+            count++;
+        }
+        if (store.selectedReporterIds().length > 0) {
+            count++;
+        }
+        return count;
+    }),
+})), withMethods((store, settingsService = inject(AXPSettingsService), taskBoardService = inject(AXPTaskBoardService), sessionService = inject(AXPSessionService), menuService = inject(AXPMenuService)) => {
+    const userScopedSettings = () => settingsService.scope(AXPPlatformScope.User);
+    let settingsSyncInitialized = false;
+    const syncTaskBoardMenuPath = () => {
+        const applicationName = sessionService.application?.name;
+        if (!applicationName) {
+            return;
+        }
+        menuService.updateItem(AXPTaskManagementMenuKeys.TaskBoard, {
+            path: buildTaskBoardMenuPath(applicationName, RootConfig.module.name, store.currentViewMode(), {
+                calendar: store.calendarLayout(),
+                timeline: store.timelineLayout(),
+                table: store.tableLayout(),
+            }),
+        });
+    };
+    const syncSettingsFromChangeEvent = (keys, values) => {
+        const patch = {};
+        let shouldSyncMenuPath = false;
+        if (keys.includes(AXMTaskBoardSettings.ColorBy)) {
+            patch.colorBy = values[AXMTaskBoardSettings.ColorBy] ?? 'dueDate';
+        }
+        if (keys.includes(AXPRegionalSetting.CalendarEvents)) {
+            patch.selectedCalendarEventTypeIds = normalizeRegionalCalendarEventIds(values[AXPRegionalSetting.CalendarEvents]);
+        }
+        if (keys.includes(AXMTaskBoardSettings.ViewMode)) {
+            const mode = values[AXMTaskBoardSettings.ViewMode];
+            if (mode) {
+                patch.currentViewMode = mode;
+                shouldSyncMenuPath = true;
+            }
+        }
+        if (keys.includes(AXMTaskBoardSettings.CalendarLayout)) {
+            const layout = values[AXMTaskBoardSettings.CalendarLayout];
+            if (layout) {
+                patch.calendarLayout = layout;
+                shouldSyncMenuPath = true;
+            }
+        }
+        if (keys.includes(AXMTaskBoardSettings.TimelineLayout)) {
+            const layout = values[AXMTaskBoardSettings.TimelineLayout];
+            if (layout) {
+                patch.timelineLayout = layout;
+                shouldSyncMenuPath = true;
+            }
+        }
+        if (keys.includes(AXMTaskBoardSettings.TableLayout)) {
+            const layout = values[AXMTaskBoardSettings.TableLayout];
+            if (layout) {
+                patch.tableLayout = layout;
+                shouldSyncMenuPath = true;
+            }
+        }
+        if (Object.keys(patch).length > 0) {
+            patchState(store, patch);
+        }
+        if (shouldSyncMenuPath) {
+            syncTaskBoardMenuPath();
+        }
+    };
+    const loadPersistedSettings = async () => {
+        const [savedDaysCount, savedDateString, savedDetailPanel, savedViewMode, savedVisibleCalendar, savedVisibleTimeline, savedVisibleTable, savedVisibleKanban, savedCalendarLayout, savedTimelineLayout, savedTableLayout, savedTaskTypeNames, savedAssigneeIds, savedReporterIds, savedPriorities, savedDueStatusKeys, savedColorBy, savedCalendarEventIds,] = await Promise.all([
+            userScopedSettings().get(AXMTaskBoardSettings.DaysCount),
+            userScopedSettings().get(AXMTaskBoardSettings.CurrentDate),
+            userScopedSettings().get(AXMTaskBoardSettings.DetailPanel),
+            userScopedSettings().get(AXMTaskBoardSettings.ViewMode),
+            userScopedSettings().get(AXMTaskBoardSettings.VisibleCalendar),
+            userScopedSettings().get(AXMTaskBoardSettings.VisibleTimeline),
+            userScopedSettings().get(AXMTaskBoardSettings.VisibleTable),
+            userScopedSettings().get(AXMTaskBoardSettings.VisibleKanban),
+            userScopedSettings().get(AXMTaskBoardSettings.CalendarLayout),
+            userScopedSettings().get(AXMTaskBoardSettings.TimelineLayout),
+            userScopedSettings().get(AXMTaskBoardSettings.TableLayout),
+            userScopedSettings().get(AXMTaskBoardSettings.SelectedTaskTypeNames),
+            userScopedSettings().get(AXMTaskBoardSettings.SelectedAssigneeIds),
+            userScopedSettings().get(AXMTaskBoardSettings.SelectedReporterIds),
+            userScopedSettings().get(AXMTaskBoardSettings.SelectedPriorities),
+            userScopedSettings().get(AXMTaskBoardSettings.SelectedDueStatusKeys),
+            userScopedSettings().get(AXMTaskBoardSettings.ColorBy),
+            settingsService.get(AXPRegionalSetting.CalendarEvents),
+        ]);
+        return {
+            savedDaysCount,
+            savedDateString,
+            savedDetailPanel,
+            savedViewMode,
+            savedVisibleCalendar,
+            savedVisibleTimeline,
+            savedVisibleTable,
+            savedVisibleKanban,
+            savedCalendarLayout,
+            savedTimelineLayout,
+            savedTableLayout,
+            savedTaskTypeNames,
+            savedAssigneeIds,
+            savedReporterIds,
+            savedPriorities,
+            savedDueStatusKeys,
+            savedColorBy,
+            savedCalendarEventIds,
+        };
+    };
+    const buildStateFromPersistedSettings = (settings, taskTypes, taskTypeOptions) => {
+        const { savedDaysCount, savedDateString, savedDetailPanel, savedViewMode, savedVisibleCalendar, savedVisibleTimeline, savedVisibleTable, savedVisibleKanban, savedCalendarLayout, savedTimelineLayout, savedTableLayout, savedTaskTypeNames, savedAssigneeIds, savedReporterIds, savedPriorities, savedDueStatusKeys, savedColorBy, savedCalendarEventIds, } = settings;
+        const visibleViewCategories = normalizeVisibleTaskBoardCategories({
+            calendar: savedVisibleCalendar,
+            timeline: savedVisibleTimeline,
+            table: savedVisibleTable,
+            kanban: savedVisibleKanban,
+        });
+        let currentDate;
+        if (savedDateString) {
+            const parsedDate = new Date(savedDateString);
+            currentDate = isNaN(parsedDate.getTime()) ? new Date() : parsedDate;
+        }
+        else {
+            currentDate = new Date();
+        }
+        const assigneeFilterHasSavedPreference = hasTaskBoardSavedAssigneePreference(savedAssigneeIds);
+        const defaultAssigneeIds = normalizeTaskBoardAssigneeIds(sessionService, resolveTaskBoardSavedAssigneeIds(sessionService, savedAssigneeIds));
+        const calendarLayout = savedCalendarLayout ?? 'monthly';
+        const timelineLayout = savedTimelineLayout ?? 'daily';
+        const tableLayout = savedTableLayout ?? 'simple';
+        let effectiveViewMode = savedViewMode || 'month';
+        const effectiveCategory = resolveTaskBoardViewCategory(effectiveViewMode);
+        if (!visibleViewCategories.includes(effectiveCategory)) {
+            const fallbackCategory = visibleViewCategories[0] ?? 'calendar';
+            effectiveViewMode = resolveTaskBoardLeafViewMode(fallbackCategory, AXM_TASK_BOARD_DEFAULT_LAYOUT_BY_CATEGORY[fallbackCategory]);
+        }
+        if (savedViewMode != null && effectiveViewMode !== savedViewMode) {
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.ViewMode, effectiveViewMode)
+                .catch((error) => console.error('Error aligning task board view mode with visible views:', error));
+        }
+        let selectedTaskTypeNames = normalizeTaskTypeFilterNames(savedTaskTypeNames ?? [], taskTypeOptions);
+        if (selectedTaskTypeNames.length === 0 &&
+            taskTypes.length > 0 &&
+            (effectiveViewMode === 'kanban' || effectiveViewMode === 'status-grouped-grid')) {
+            selectedTaskTypeNames = [taskTypes[0].name];
+        }
+        return {
+            daysCount: savedDaysCount || 7,
+            detailPanel: savedDetailPanel || false,
+            currentViewMode: effectiveViewMode,
+            visibleViewCategories,
+            calendarLayout,
+            timelineLayout,
+            tableLayout,
+            currentDate,
+            selectedTaskTypeNames,
+            selectedAssigneeIds: defaultAssigneeIds,
+            assigneeFilterHasSavedPreference,
+            selectedReporterIds: savedReporterIds || [],
+            selectedPriorities: normalizeTaskBoardPriorityFilterKeys(savedPriorities),
+            selectedDueStatusKeys: normalizeDueStatusFilterKeys(savedDueStatusKeys),
+            colorBy: savedColorBy || 'dueDate',
+            selectedCalendarEventTypeIds: normalizeRegionalCalendarEventIds(savedCalendarEventIds),
+        };
+    };
+    return {
+        async reloadTaskTypes(options) {
+            taskBoardService.clearProviderCache();
+            const taskTypes = await taskBoardService.getTaskTypes(options);
+            patchState(store, {
+                taskTypes,
+                taskTypeOptions: taskBoardService.getTaskTypeOptions(),
+            });
+        },
+        async initialize() {
+            patchState(store, { isLoading: true });
+            try {
+                const persistedSettings = await loadPersistedSettings();
+                let taskTypes = [];
+                let taskTypeOptions = [];
+                try {
+                    taskTypes = await taskBoardService.getTaskTypes();
+                    taskTypeOptions = taskBoardService.getTaskTypeOptions();
+                }
+                catch (error) {
+                    console.error('Error loading task board task types:', error);
+                }
+                patchState(store, {
+                    taskTypes,
+                    taskTypeOptions,
+                    ...buildStateFromPersistedSettings(persistedSettings, taskTypes, taskTypeOptions),
+                    isLoading: false,
+                });
+                syncTaskBoardMenuPath();
+                if (!settingsSyncInitialized) {
+                    settingsSyncInitialized = true;
+                    settingsService.onChanged.subscribe((event) => {
+                        if (event.scope !== AXPPlatformScope.User) {
+                            return;
+                        }
+                        syncSettingsFromChangeEvent(event.keys, event.values);
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Error initializing TaskBoard ViewModel:', error);
+                let persistedSettingsPatch = {};
+                try {
+                    const persistedSettings = await loadPersistedSettings();
+                    persistedSettingsPatch = buildStateFromPersistedSettings(persistedSettings, [], []);
+                }
+                catch (settingsError) {
+                    console.error('Error loading task board persisted settings:', settingsError);
+                }
+                const fallbackAssigneeIds = normalizeTaskBoardAssigneeIds(sessionService, resolveTaskBoardSavedAssigneeIds(sessionService, null));
+                patchState(store, {
+                    detailPanel: false,
+                    currentViewMode: 'month',
+                    visibleViewCategories: ['calendar', 'timeline', 'table', 'kanban'],
+                    calendarLayout: 'monthly',
+                    timelineLayout: 'daily',
+                    tableLayout: 'simple',
+                    currentDate: new Date(),
+                    selectedTaskTypeNames: [],
+                    selectedAssigneeIds: fallbackAssigneeIds,
+                    assigneeFilterHasSavedPreference: false,
+                    selectedPriorities: [],
+                    selectedDueStatusKeys: [],
+                    colorBy: 'dueDate',
+                    selectedReporterIds: [],
+                    selectedCalendarEventTypeIds: [],
+                    taskTypes: store.taskTypes(),
+                    taskTypeOptions: store.taskTypeOptions(),
+                    isLoading: false,
+                    ...persistedSettingsPatch,
+                });
+            }
+        },
+        setViewMode(mode) {
+            let category = resolveTaskBoardViewCategory(mode);
+            const allowed = store.visibleViewCategories();
+            if (!allowed.includes(category)) {
+                const fallbackCategory = allowed[0] ?? category;
+                mode = resolveTaskBoardLeafViewMode(fallbackCategory, this.getLayoutForCategory(fallbackCategory));
+                category = fallbackCategory;
+            }
+            const layout = resolveTaskBoardViewLayout(mode);
+            if (layout) {
+                this.patchLayoutForCategory(category, layout);
+            }
+            this.applyLeafViewMode(mode);
+        },
+        setViewCategory(category) {
+            const allowed = store.visibleViewCategories();
+            const effectiveCategory = allowed.includes(category) ? category : (allowed[0] ?? category);
+            const layout = this.getLayoutForCategory(effectiveCategory);
+            this.applyLeafViewMode(resolveTaskBoardLeafViewMode(effectiveCategory, layout));
+        },
+        setViewLayout(category, layout) {
+            this.patchLayoutForCategory(category, layout);
+            if (resolveTaskBoardViewCategory(store.currentViewMode()) === category) {
+                this.applyLeafViewMode(resolveTaskBoardLeafViewMode(category, layout));
+            }
+            else {
+                this.persistLayout(category, layout);
+            }
+        },
+        getLayoutForCategory(category) {
+            switch (category) {
+                case 'calendar':
+                    return store.calendarLayout();
+                case 'timeline':
+                    return store.timelineLayout();
+                case 'table':
+                    return store.tableLayout();
+                default:
+                    return null;
+            }
+        },
+        patchLayoutForCategory(category, layout) {
+            switch (category) {
+                case 'calendar':
+                    patchState(store, { calendarLayout: layout });
+                    break;
+                case 'timeline':
+                    patchState(store, { timelineLayout: layout });
+                    break;
+                case 'table':
+                    patchState(store, { tableLayout: layout });
+                    break;
+            }
+            this.persistLayout(category, layout);
+        },
+        persistLayout(category, layout) {
+            const key = category === 'calendar'
+                ? AXMTaskBoardSettings.CalendarLayout
+                : category === 'timeline'
+                    ? AXMTaskBoardSettings.TimelineLayout
+                    : AXMTaskBoardSettings.TableLayout;
+            userScopedSettings()
+                .set(key, layout)
+                .catch((error) => console.error('Error saving task board view layout:', error));
+        },
+        applyLeafViewMode(mode) {
+            if ((mode === 'kanban' || mode === 'status-grouped-grid') &&
+                store.selectedTaskTypeNames().length === 0) {
+                const firstTaskType = store.taskTypes()[0];
+                if (firstTaskType) {
+                    this.setSelectedTaskTypeNames([firstTaskType.name]);
+                }
+            }
+            if ((mode === 'kanban' || mode === 'status-grouped-grid') &&
+                store.selectedTaskTypeNames().length > 1) {
+                this.setSelectedTaskTypeNames([store.selectedTaskTypeNames()[0]]);
+            }
+            patchState(store, { currentViewMode: mode });
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.ViewMode, mode)
+                .catch((error) => console.error('Error saving task board view mode:', error));
+            syncTaskBoardMenuPath();
+        },
+        setCurrentDate(date) {
+            patchState(store, { currentDate: new Date(date) });
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.CurrentDate, date.toISOString())
+                .catch((error) => console.error('Error saving current date:', error));
+        },
+        async restoreQueryFiltersFromSettings() {
+            const persistedSettings = await loadPersistedSettings();
+            const filterPatch = buildStateFromPersistedSettings(persistedSettings, store.taskTypes(), store.taskTypeOptions());
+            patchState(store, {
+                selectedTaskTypeNames: filterPatch.selectedTaskTypeNames ?? [],
+                selectedAssigneeIds: filterPatch.selectedAssigneeIds ?? [],
+                assigneeFilterHasSavedPreference: filterPatch.assigneeFilterHasSavedPreference ?? false,
+                selectedReporterIds: filterPatch.selectedReporterIds ?? [],
+            });
+        },
+        clearQueryFilters() {
+            const defaultAssigneeIds = normalizeTaskBoardAssigneeIds(sessionService, resolveTaskBoardSavedAssigneeIds(sessionService, null));
+            patchState(store, {
+                selectedTaskTypeNames: [],
+                selectedAssigneeIds: defaultAssigneeIds,
+                assigneeFilterHasSavedPreference: false,
+                selectedReporterIds: [],
+            });
+        },
+        setSelectedTaskTypeNames(taskTypeNames, isQueryParam = false) {
+            patchState(store, { selectedTaskTypeNames: taskTypeNames });
+            if (isQueryParam)
+                return;
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.SelectedTaskTypeNames, taskTypeNames)
+                .catch((error) => console.error('Error saving selected task type filter:', error));
+        },
+        setSelectedAssigneeIds(assigneeIds, isQueryParam = false, persistPreference = !isQueryParam) {
+            const normalizedAssigneeIds = normalizeTaskBoardAssigneeIds(sessionService, assigneeIds);
+            patchState(store, {
+                selectedAssigneeIds: normalizedAssigneeIds,
+                ...(persistPreference ? { assigneeFilterHasSavedPreference: true } : {}),
+            });
+            if (isQueryParam || !persistPreference)
+                return;
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.SelectedAssigneeIds, normalizedAssigneeIds)
+                .catch((error) => console.error('Error saving selected assignee filter:', error));
+        },
+        setSelectedReporterIds(reporterIds, isQueryParam = false) {
+            patchState(store, { selectedReporterIds: reporterIds });
+            if (isQueryParam)
+                return;
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.SelectedReporterIds, reporterIds)
+                .catch((error) => console.error('Error saving selected reporter filter:', error));
+        },
+        setSelectedPriorities(priorities, isQueryParam = false) {
+            patchState(store, { selectedPriorities: priorities });
+            if (isQueryParam)
+                return;
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.SelectedPriorities, priorities)
+                .catch((error) => console.error('Error saving selected priority filter:', error));
+        },
+        setSelectedDueStatusKeys(dueStatusKeys, isQueryParam = false) {
+            patchState(store, { selectedDueStatusKeys: dueStatusKeys });
+            if (isQueryParam)
+                return;
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.SelectedDueStatusKeys, dueStatusKeys)
+                .catch((error) => console.error('Error saving selected due status filter:', error));
+        },
+        setColorBy(colorBy) {
+            patchState(store, { colorBy });
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.ColorBy, colorBy)
+                .catch((error) => console.error('Error saving task board color by:', error));
+        },
+        setSelectedCalendarEventTypeIds(eventTypeIds) {
+            patchState(store, { selectedCalendarEventTypeIds: eventTypeIds });
+            userScopedSettings()
+                .set(AXPRegionalSetting.CalendarEvents, eventTypeIds)
+                .catch((error) => console.error('Error saving selected calendar events:', error));
+        },
+        /**
+         * Sets the currently selected task. Pass `null` to clear the selection.
+         * @param task The task to select, or null.
+         */
+        selectTask(task) {
+            patchState(store, { selectedTask: task });
+        },
+        /**
+         * A convenience method to clear the currently selected task.
+         */
+        clearSelectedTask() {
+            patchState(store, { selectedTask: null });
+        },
+        openDetailPanel() {
+            patchState(store, { detailPanel: true });
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.DetailPanel, true)
+                .catch((error) => console.error('Error saving detail panel:', error));
+        },
+        closeDetailPanel() {
+            patchState(store, { detailPanel: false });
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.DetailPanel, false)
+                .catch((error) => console.error('Error saving detail panel:', error));
+        },
+        toggleDetailPanel() {
+            const detailPanel = !store.detailPanel();
+            patchState(store, { detailPanel: detailPanel });
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.DetailPanel, detailPanel)
+                .catch((error) => console.error('Error saving detail panel:', error));
+        },
+        async getStatusName(key, provider) {
+            return taskBoardService.getStatusName(key, provider);
+        },
+        /**
+         * Sets the start date for a new range selection.
+         * Pass `null` to clear the selection.
+         * @param date The start date of the range.
+         */
+        setRangeStartDate(date) {
+            patchState(store, { rangeStartDate: date });
+        },
+        setDaysCount(days) {
+            const count = Math.max(1, days);
+            patchState(store, { daysCount: count });
+            userScopedSettings()
+                .set(AXMTaskBoardSettings.DaysCount, count)
+                .catch((error) => console.error('Error saving days count:', error));
+        },
+    };
+}));
+
+//#region ---- Imports ----
+const RESET_TASK_BOARD_FILTERS_ASSIGN_TO_CURRENT_USER_COMMAND_KEY = AXPTaskManagementCommandKeys.TaskBoard.ResetFiltersAssignToCurrentUser;
+//#endregion
+/**
+ * Clears task-board filters, scopes assignee to the signed-in user, and requests a board refresh.
+ */
+class ResetTaskBoardFiltersAssignToCurrentUserCommand {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.sessionService = inject(AXPSessionService);
+        this.taskBoardService = inject(AXPTaskBoardService);
+        this.vm = inject(AXMTaskBoardViewModel);
+    }
+    //#endregion
+    //#region ---- Command Implementation ----
+    async execute(_input) {
+        const currentUserId = this.sessionService.user?.id;
+        if (isNil(currentUserId)) {
+            return { success: false, message: { text: 'Current user is not available.' } };
+        }
+        this.vm.setSelectedTaskTypeNames([], false);
+        this.vm.setSelectedReporterIds([], false);
+        this.vm.setSelectedPriorities([], false);
+        this.vm.setSelectedDueStatusKeys([], false);
+        this.vm.setSelectedAssigneeIds([currentUserId], false, true);
+        this.ensureTaskTypeForGroupedViews();
+        this.taskBoardService.requestRefresh();
+        return { success: true, kind: 'object', data: undefined };
+    }
+    //#endregion
+    //#region ---- Helpers ----
+    ensureTaskTypeForGroupedViews() {
+        const viewMode = this.vm.currentViewMode();
+        if (viewMode !== 'kanban' && viewMode !== 'status-grouped-grid') {
+            return;
+        }
+        if (this.vm.selectedTaskTypeNames().length > 0) {
+            return;
+        }
+        const firstTaskType = this.vm.taskTypes()[0];
+        if (firstTaskType) {
+            this.vm.setSelectedTaskTypeNames([firstTaskType.name]);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ResetTaskBoardFiltersAssignToCurrentUserCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ResetTaskBoardFiltersAssignToCurrentUserCommand, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ResetTaskBoardFiltersAssignToCurrentUserCommand, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+var resetFiltersAssignToCurrentUser_command = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    RESET_TASK_BOARD_FILTERS_ASSIGN_TO_CURRENT_USER_COMMAND_KEY: RESET_TASK_BOARD_FILTERS_ASSIGN_TO_CURRENT_USER_COMMAND_KEY,
+    ResetTaskBoardFiltersAssignToCurrentUserCommand: ResetTaskBoardFiltersAssignToCurrentUserCommand
+});
+
+class AXPDueStatusProvider {
+}
+const AXP_DUE_STATUS_PROVIDERS = new InjectionToken('AXP_DUE_STATUS_PROVIDERS');
+function getTaskDueStatusKey(task) {
+    const data = task.data;
+    return data?.dueStatusKey;
+}
+function matchesTaskDueStatusFilter(task, dueStatusKeys) {
+    if (dueStatusKeys.length === 0) {
+        return true;
+    }
+    const key = getTaskDueStatusKey(task);
+    return key != null && dueStatusKeys.includes(key);
+}
+
+function startOfLocalDay(date) {
+    const value = new Date(date);
+    value.setHours(0, 0, 0, 0);
+    return value;
+}
+function endOfLocalDay(date) {
+    const value = new Date(date);
+    value.setHours(23, 59, 59, 999);
+    return value;
+}
+function isSameLocalDay(a, b) {
+    return (a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate());
+}
+function addLocalDays(date, days) {
+    const value = new Date(date);
+    value.setDate(value.getDate() + days);
+    return value;
+}
+function getStartOfLocalWeek(date, weekStartsOn) {
+    const day = startOfLocalDay(date);
+    const weekday = day.getDay();
+    const diff = (weekday - weekStartsOn + 7) % 7;
+    day.setDate(day.getDate() - diff);
+    return day;
+}
+function getEndOfLocalWeek(date, weekStartsOn) {
+    const start = getStartOfLocalWeek(date, weekStartsOn);
+    return endOfLocalDay(addLocalDays(start, 6));
+}
+function matchesDueStatusKey(context, key) {
+    const today = startOfLocalDay(context.now);
+    const tomorrow = startOfLocalDay(addLocalDays(context.now, 1));
+    const weekEnd = getEndOfLocalWeek(context.now, context.weekStartsOn);
+    if (key === 'completed') {
+        return context.bookmarkConsumed;
+    }
+    if (key === 'no-due-date') {
+        return !context.bookmarkConsumed && !context.hasExplicitDueDate;
+    }
+    if (!context.hasExplicitDueDate || !context.dueDate || context.bookmarkConsumed) {
+        return false;
+    }
+    const dueDay = startOfLocalDay(context.dueDate);
+    if (key === 'overdue') {
+        return dueDay.getTime() < today.getTime();
+    }
+    if (key === 'due-today') {
+        return isSameLocalDay(dueDay, today);
+    }
+    if (key === 'due-tomorrow') {
+        return isSameLocalDay(dueDay, tomorrow);
+    }
+    if (key === 'due-this-week') {
+        return dueDay.getTime() > tomorrow.getTime() && dueDay.getTime() <= weekEnd.getTime();
+    }
+    if (key === 'upcoming') {
+        return dueDay.getTime() > weekEnd.getTime();
+    }
+    return false;
+}
+function resolveDueStatusFromDefinitions(definitions, context) {
+    const ordered = [...definitions].sort((a, b) => a.order - b.order);
+    for (const definition of ordered) {
+        if (matchesDueStatusKey(context, definition.name)) {
+            return definition;
+        }
+    }
+    return null;
+}
+
+const DEFAULT_DUE_STATUS_DEFINITIONS = [
+    {
+        name: 'completed',
+        title: '@task-management:task-board.due-status.completed',
+        color: 'success',
+        icon: 'fa-light fa-circle-check',
+        order: 0,
+    },
+    {
+        name: 'no-due-date',
+        title: '@task-management:task-board.due-status.no-due-date',
+        color: 'neutral',
+        icon: 'fa-light fa-calendar-xmark',
+        order: 1,
+    },
+    {
+        name: 'overdue',
+        title: '@task-management:task-board.due-status.overdue',
+        color: 'danger',
+        icon: 'fa-light fa-calendar-exclamation',
+        order: 2,
+    },
+    {
+        name: 'due-today',
+        title: '@task-management:task-board.due-status.due-today',
+        color: 'warning',
+        icon: 'fa-light fa-calendar-day',
+        order: 3,
+    },
+    {
+        name: 'due-tomorrow',
+        title: '@task-management:task-board.due-status.due-tomorrow',
+        color: 'accent3',
+        icon: 'fa-light fa-calendar-plus',
+        order: 4,
+    },
+    {
+        name: 'due-this-week',
+        title: '@task-management:task-board.due-status.due-this-week',
+        color: 'primary',
+        icon: 'fa-light fa-calendar-week',
+        order: 5,
+    },
+    {
+        name: 'upcoming',
+        title: '@task-management:task-board.due-status.upcoming',
+        color: 'secondary',
+        icon: 'fa-light fa-calendar',
+        order: 6,
+    },
+];
+class AXMDefaultDueStatusProvider extends AXPDueStatusProvider {
+    constructor() {
+        super(...arguments);
+        this.key = 'default';
+        this.priority = 0;
+    }
+    getDefinitions() {
+        return DEFAULT_DUE_STATUS_DEFINITIONS;
+    }
+    resolve(context) {
+        return resolveDueStatusFromDefinitions(DEFAULT_DUE_STATUS_DEFINITIONS, context);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMDefaultDueStatusProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMDefaultDueStatusProvider, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMDefaultDueStatusProvider, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function getDefaultDueStatusDefinitions() {
+    return DEFAULT_DUE_STATUS_DEFINITIONS;
+}
+
+class AXPDueStatusProviderService {
+    constructor() {
+        this.localeService = inject(AXLocaleService);
+        this.registeredProviders = inject(AXP_DUE_STATUS_PROVIDERS, { optional: true }) ?? [];
+        this.fallbackProvider = inject(AXMDefaultDueStatusProvider);
+    }
+    getDefinitions(options) {
+        return this.selectProvider(options).getDefinitions();
+    }
+    resolveForTask(task, options) {
+        const data = task.data;
+        const context = {
+            now: new Date(),
+            dueDate: task.endDate ? new Date(task.endDate) : null,
+            hasExplicitDueDate: data?.hasExplicitDueDate === true,
+            bookmarkConsumed: data?.bookmarkConsumed === true,
+            weekStartsOn: this.resolveWeekStartsOn(),
+        };
+        const definition = this.selectProvider(options).resolve(context);
+        if (!definition) {
+            return null;
+        }
+        return {
+            name: definition.name,
+            title: definition.title,
+            color: definition.color,
+            icon: definition.icon,
+        };
+    }
+    attachDueStatusToTask(task, options) {
+        const presentation = this.resolveForTask(task, options);
+        if (!presentation) {
+            return task;
+        }
+        return {
+            ...task,
+            data: {
+                ...(task.data ?? {}),
+                dueStatusKey: presentation.name,
+                dueStatus: presentation,
+            },
+        };
+    }
+    selectProvider(options) {
+        const providers = [...this.registeredProviders, this.fallbackProvider].sort((a, b) => b.priority - a.priority);
+        if (!options?.workflowDefinitionId && !options?.activityType) {
+            return providers[providers.length - 1] ?? this.fallbackProvider;
+        }
+        const matched = providers.find((provider) => {
+            if (options.workflowDefinitionId && provider.key === options.workflowDefinitionId) {
+                return true;
+            }
+            return Boolean(options.activityType && provider.key === options.activityType);
+        });
+        return matched ?? providers[providers.length - 1] ?? this.fallbackProvider;
+    }
+    resolveWeekStartsOn() {
+        return this.localeService.activeProfile()?.calendar?.week?.startsOn ?? 0;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPDueStatusProviderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPDueStatusProviderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPDueStatusProviderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const BADGE_COLORS = new Set([
+    'primary',
+    'secondary',
+    'success',
+    'warning',
+    'danger',
+    'accent1',
+    'accent2',
+    'accent3',
+    'neutral',
+    'ghost',
+]);
+/** Plain gray/white tokens → soft secondary (`neutral` → secondary-lightest in CSS). */
+const NON_CHROMATIC_BADGE_COLORS = new Set([
+    'gray',
+    'grey',
+    'white',
+    'black',
+    'default',
+    'light',
+    'lighter',
+    'lightest',
+    'natural',
+]);
+/** Maps entity status semantic colors to badge/chip tokens (`info` → `accent3`). */
+function mapEntityStatusColorForBadge(color, statusId) {
+    const normalized = color?.trim().toLowerCase();
+    if (normalized === 'info') {
+        return 'accent3';
+    }
+    if (normalized && NON_CHROMATIC_BADGE_COLORS.has(normalized)) {
+        return 'neutral';
+    }
+    if (normalized && BADGE_COLORS.has(normalized)) {
+        return normalized;
+    }
+    return resolveDefaultTaskStatusColor(statusId);
+}
+function resolveDefaultTaskStatusColor(statusId) {
+    if (String(statusId) === AXPSystemStatuses.Pending.name) {
+        return 'warning';
+    }
+    return 'primary';
+}
+/** Resolves the chip color for a task row, aligned with workflow popover badge layout. */
+function resolveTaskBoardStatusColor(task) {
+    if (task.status.color) {
+        return task.status.color;
+    }
+    const data = task.data;
+    const rawColor = get(data, 'entityStatusDefinition.color') ?? get(data, 'statusColor');
+    return mapEntityStatusColorForBadge(rawColor, task.status.id);
+}
+/** Calendar placement for tasks without an explicit due date (received/created day, all-day). */
+function resolveTaskBoardCalendarPlacement(task) {
+    const hasExplicitDueDate = get(task.data, 'hasExplicitDueDate') === true;
+    if (hasExplicitDueDate) {
+        const due = new Date(task.endDate);
+        const dayStart = new Date(due);
+        dayStart.setHours(0, 0, 0, 0);
+        const dayEnd = new Date(due);
+        dayEnd.setHours(23, 59, 59, 999);
+        return {
+            startDate: dayStart,
+            endDate: dayEnd,
+            allDay: true,
+        };
+    }
+    const received = task.createdAt ? new Date(task.createdAt) : new Date(task.startDate);
+    const dayStart = new Date(received);
+    dayStart.setHours(0, 0, 0, 0);
+    const dayEnd = new Date(received);
+    dayEnd.setHours(23, 59, 59, 999);
+    return {
+        startDate: dayStart,
+        endDate: dayEnd,
+        allDay: true,
+    };
+}
+/**
+ * Returns tasks whose effective scheduling range overlaps the filter range (inclusive).
+ * Open tasks without an explicit due date are always included (widget-style visibility).
+ */
+function resolveTaskBoardSchedulingRange(task) {
+    const hasExplicitDueDate = get(task.data, 'hasExplicitDueDate') === true;
+    if (hasExplicitDueDate) {
+        const due = new Date(task.endDate);
+        return { from: due, end: due };
+    }
+    const received = task.createdAt ? new Date(task.createdAt) : new Date(task.startDate);
+    return { from: received, end: received };
+}
+/** Whether a task should appear for the task board's active date navigator range. */
+function taskOverlapsFilterRange(task, range) {
+    if (!range?.from || !range?.end) {
+        return true;
+    }
+    const hasExplicitDueDate = get(task.data, 'hasExplicitDueDate') === true;
+    const bookmarkConsumed = get(task.data, 'bookmarkConsumed') === true;
+    if (!hasExplicitDueDate && !bookmarkConsumed) {
+        return true;
+    }
+    const { from, end } = resolveTaskBoardSchedulingRange(task);
+    const rangeStart = range.from.getTime();
+    const rangeEnd = range.end.getTime();
+    const taskStart = from.getTime();
+    const taskEnd = end.getTime();
+    return taskStart <= rangeEnd && taskEnd >= rangeStart;
+}
+function filterTasksOverlappingRange(tasks, range) {
+    if (!range?.from || !range?.end) {
+        return tasks;
+    }
+    return tasks.filter((task) => taskOverlapsFilterRange(task, range));
+}
+
+/**
+ * Soft secondary fallback class token.
+ * CSS maps `neutral` / `ghost` to `secondary-lightest` / `secondary-lighter` surfaces
+ * (never plain gray/white).
+ */
+const TASK_BOARD_SOFT_SECONDARY_TOKEN = 'neutral';
+const SURFACE_CLASS_TOKENS = new Set([
+    'primary',
+    'secondary',
+    'success',
+    'warning',
+    'danger',
+    'accent1',
+    'accent2',
+    'accent3',
+    'neutral',
+    'ghost',
+]);
+/** Gray / white / natural tokens that blend into the calendar background. */
+const NON_CHROMATIC_SURFACE_TOKENS = new Set([
+    'gray',
+    'grey',
+    'white',
+    'black',
+    'default',
+    'light',
+    'lighter',
+    'lightest',
+    'natural',
+]);
+function resolveTaskBoardAccentColor(task, colorBy) {
+    switch (colorBy) {
+        case 'dueDate':
+            return resolveDueStatusAccentColor(task);
+        case 'priority':
+            return task.priority
+                ? getTaskPriorityColor(normalizeTaskPriority(task.priority))
+                : TASK_BOARD_SOFT_SECONDARY_TOKEN;
+        case 'status':
+            return resolveTaskBoardStatusColor(task);
+        default:
+            return resolveDueStatusAccentColor(task);
+    }
+}
+function resolveDueStatusAccentColor(task) {
+    const dueStatus = get(task.data, 'dueStatus');
+    if (dueStatus?.color) {
+        return dueStatus.color;
+    }
+    if (get(task.data, 'hasExplicitDueDate') !== true) {
+        return TASK_BOARD_SOFT_SECONDARY_TOKEN;
+    }
+    return 'secondary';
+}
+function normalizeSurfaceClassToken(colorToken) {
+    const safe = colorToken.replace(/[^a-z0-9-]/gi, '').toLowerCase();
+    if (!safe || NON_CHROMATIC_SURFACE_TOKENS.has(safe)) {
+        return TASK_BOARD_SOFT_SECONDARY_TOKEN;
+    }
+    return SURFACE_CLASS_TOKENS.has(safe) ? safe : TASK_BOARD_SOFT_SECONDARY_TOKEN;
+}
+/** Maps a color token to a static BEM class backed by Tailwind @apply rules in task-board-surface.css. */
+function buildTaskSurfaceCssClass(colorToken) {
+    return `axm-task-board-surface--${normalizeSurfaceClassToken(colorToken)}`;
+}
+/** Accent stripe modifier for dashboard widget rows. */
+function buildTaskAccentSurfaceCssClass(colorToken) {
+    return `axm-task-board-accent--${normalizeSurfaceClassToken(colorToken)}`;
+}
+/** @deprecated Use {@link buildTaskSurfaceCssClass}. */
+function buildTaskAccentCssClass(colorToken) {
+    return buildTaskSurfaceCssClass(colorToken);
+}
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Component   ----
+class AXMTaskBoardDefaultTaskPopoverComponent extends AXPTaskPopoverComponent {
+    constructor() {
+        super();
+        //#region ----   Inputs   ----
+        this.task = input.required(/* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "task" }] : /* istanbul ignore next */ []));
+        //#endregion
+        //#region ----   Services & Dependencies   ----
+        this.taskBoardService = inject(AXPTaskBoardService);
+        this.calendarService = inject(AXCalendarService);
+        //#endregion
+        //#region ----   Actions   ----
+        this.taskActions = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "taskActions" }] : /* istanbul ignore next */ []));
+        this.primaryActions = computed(() => this.taskActions().filter((action) => (action.priority ?? 'secondary') === 'primary'), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "primaryActions" }] : /* istanbul ignore next */ []));
+        this.secondaryActions = computed(() => this.taskActions().filter((action) => (action.priority ?? 'secondary') === 'secondary'), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "secondaryActions" }] : /* istanbul ignore next */ []));
+        effect(() => {
+            const currentTask = this.task();
+            if (!currentTask?.provider) {
+                this.taskActions.set([]);
+                return;
+            }
+            const provider = this.taskBoardService.getProvider(currentTask.provider);
+            if (!provider) {
+                this.taskActions.set([]);
+                return;
+            }
+            provider
+                .getActions(currentTask)
+                .then((actions) => this.taskActions.set((actions ?? []).map((action) => ({
+                ...action,
+                priority: action.priority ?? 'secondary',
+            }))))
+                .catch((error) => {
+                console.error('[TaskBoardDefaultTaskPopover] Failed to load actions:', error);
+                this.taskActions.set([]);
+            });
+        });
+    }
+    getActionColor(action) {
+        return action.color ?? null;
+    }
+    async executeAction(action) {
+        const currentTask = this.task();
+        if (!currentTask?.provider || !action.command) {
+            return;
+        }
+        try {
+            const result = await this.taskBoardService.executeCommand(action.command, currentTask.provider);
+            if (result?.success === false || result === null) {
+                return;
+            }
+            this.closePopover();
+            this.taskBoardService.requestRefresh(currentTask.provider);
+        }
+        catch (error) {
+            console.error('[TaskBoardDefaultTaskPopover] executeAction failed:', error);
+        }
+    }
+    //#endregion
+    //#region ----   Date Formatting   ----
+    formatDateRange(task) {
+        if (task.allDay) {
+            const start = this.calendarService.create(task.startDate);
+            const end = this.calendarService.create(task.endDate);
+            if (start.date.getTime() === end.date.getTime()) {
+                return this.formatDate(task.startDate);
+            }
+            const startFormatted = this.formatDate(task.startDate);
+            const endFormatted = this.formatDate(task.endDate);
+            if (start.date.getMonth() === end.date.getMonth() && start.date.getFullYear() === end.date.getFullYear()) {
+                const startDay = start.date.getDate();
+                const endDay = end.date.getDate();
+                const monthYear = start.format('MMM YYYY');
+                return `${startDay} - ${endDay}, ${monthYear}`;
+            }
+            return `${startFormatted} - ${endFormatted}`;
+        }
+        if (this.isMultiDay(task)) {
+            return `${this.formatDateTime(task.startDate)} - ${this.formatDateTime(task.endDate)}`;
+        }
+        const dateFormatted = this.formatDate(task.startDate);
+        const timeRange = `${this.formatTime(task.startDate)} - ${this.formatTime(task.endDate)}`;
+        return `${dateFormatted} ${timeRange}`;
+    }
+    formatTime(date) {
+        return this.calendarService.create(date).format('HH:mm');
+    }
+    formatDate(date) {
+        return this.calendarService.create(date).format('MMM DD, YYYY');
+    }
+    formatDateTime(date) {
+        return this.calendarService.create(date).format('MMM DD, YYYY HH:mm');
+    }
+    isMultiDay(task) {
+        if (task.allDay) {
+            const start = this.calendarService.create(task.startDate);
+            const end = this.calendarService.create(task.endDate);
+            return start.date.getTime() !== end.date.getTime();
+        }
+        const start = this.calendarService.create(task.startDate);
+        const end = this.calendarService.create(task.endDate);
+        return (start.date.getDate() !== end.date.getDate() ||
+            start.date.getMonth() !== end.date.getMonth() ||
+            start.date.getFullYear() !== end.date.getFullYear());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskBoardDefaultTaskPopoverComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMTaskBoardDefaultTaskPopoverComponent, isStandalone: true, selector: "axm-task-board-default-task-popover", inputs: { task: { classPropertyName: "task", publicName: "task", isSignal: true, isRequired: true, transformFunction: null } }, usesInheritance: true, ngImport: i0, template: `
+    @if (task().description) {
+      <p class="task-popover__description">{{ task().description }}</p>
+    }
+
+    <div class="task-popover__content">
+      <div class="task-popover__info-item">
+        <div class="task-popover__icon">
+          <i class="fa-light fa-clock"></i>
+        </div>
+        <div class="task-popover__info-content">
+          <span class="task-popover__info-text">{{ formatDateRange(task()) }}</span>
+        </div>
+      </div>
+
+      @if (task().status) {
+        <div class="task-popover__info-item">
+          <div class="task-popover__icon">
+            <i class="fa-light fa-flag"></i>
+          </div>
+          <div class="task-popover__info-content">
+            <span class="task-popover__info-text">{{ task().status.title }}</span>
+          </div>
+        </div>
+      }
+
+      @if (task().assignee) {
+        <div class="task-popover__info-item">
+          <div class="task-popover__icon">
+            <i class="fa-light fa-user"></i>
+          </div>
+          <div class="task-popover__info-content">
+            <span class="task-popover__info-text">{{
+              task().assignee?.fullName || task().assignee?.username || 'Unassigned'
+            }}</span>
+          </div>
+        </div>
+      }
+
+      @if (task().priority) {
+        <div class="task-popover__info-item">
+          <div class="task-popover__icon task-popover__icon--priority" [attr.data-priority]="task().priority">
+            <i class="fa-light fa-exclamation-circle"></i>
+          </div>
+          <div class="task-popover__info-content">
+            <span class="task-popover__info-text task-popover__priority" [attr.data-priority]="task().priority">
+              {{ task().priority }}
+            </span>
+          </div>
+        </div>
+      }
+    </div>
+
+    @if (taskActions().length > 0) {
+      <div class="task-popover__actions">
+        <div class="task-popover__actions-group">
+          @if (primaryActions().length > 0) {
+            @for (action of primaryActions(); track action.name || action.title) {
+              <ax-button
+                [look]="'solid'"
+                [color]="getActionColor(action)"
+                (onClick)="executeAction(action)"
+                [disabled]="action.disabled === true"
+                [text]="(action.title | translate | async)!"
+              >
+                @if (action.icon) {
+                  <ax-prefix>
+                    <ax-icon>
+                      <i [class]="action.icon"></i>
+                    </ax-icon>
+                  </ax-prefix>
+                }
+              </ax-button>
+            }
+          }
+
+          @if (secondaryActions().length > 0) {
+            <ax-button [look]="'blank'">
+              <ax-prefix>
+                <ax-icon icon="fa-light fa-ellipsis-vertical"></ax-icon>
+              </ax-prefix>
+              <ax-dropdown-panel>
+                <ax-button-item-list>
+                  @for (action of secondaryActions(); track action.name || action.title) {
+                    <ax-button-item
+                      [text]="(action.title | translate | async)!"
+                      [disabled]="action.disabled === true"
+                      (onClick)="executeAction(action)"
+                    >
+                      @if (action.icon) {
+                        <ax-prefix>
+                          <ax-icon>
+                            <i [class]="action.icon"></i>
+                          </ax-icon>
+                        </ax-prefix>
+                      }
+                    </ax-button-item>
+                  }
+                </ax-button-item-list>
+              </ax-dropdown-panel>
+            </ax-button>
+          }
+        </div>
+      </div>
+    }
+  `, isInline: true, styles: ["@layer properties;.task-popover{display:flex;flex-direction:column;overflow:hidden;background:rgba(var(--ax-sys-color-lightest-surface));border-radius:12px;min-width:280px;max-width:420px}.task-popover .task-popover__header{padding:20px 20px 16px;border-bottom:1px solid var(--ax-sys-color-border);background:linear-gradient(to bottom,var(--ax-sys-color-lightest-surface),var(--ax-sys-color-lighter-surface))}.task-popover .task-popover__title-section{display:flex;flex-direction:column;gap:8px}.task-popover .task-popover__title-row{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}.task-popover .task-popover__title{margin:0;min-width:0px;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;--tw-leading: var(--leading-snug, 1.375);line-height:var(--leading-snug, 1.375);--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600);font-size:18px;color:var(--ax-sys-color-text-primary)}.task-popover .task-popover__close-btn{display:flex;flex-shrink:0;cursor:pointer;align-items:center;justify-content:center;border-style:var(--tw-border-style);border-width:0px;background:none;padding:4px;color:var(--ax-sys-color-text-neutral-600);transition:color .2s ease;border-radius:4px}.task-popover .task-popover__close-btn:hover{color:var(--ax-sys-color-text-primary);background:var(--ax-sys-color-lighter-surface)}.task-popover .task-popover__close-btn:active{background:var(--ax-sys-color-light-surface)}.task-popover .task-popover__close-btn ax-icon{display:block;width:16px;height:16px}.task-popover .task-popover__body{display:flex;flex-direction:column}.task-popover .task-popover__description{margin:0;overflow:hidden;text-overflow:ellipsis;font-size:14px;line-height:1.5;color:var(--ax-sys-color-text-secondary);padding:0 20px 12px;display:-webkit-box;-webkit-line-clamp:3;line-clamp:3;-webkit-box-orient:vertical}.task-popover .task-popover__content{display:flex;flex:1;flex-direction:column;padding:16px 20px;gap:12px}.task-popover .task-popover__info-item{display:flex;align-items:flex-start;gap:12px;min-height:24px}.task-popover .task-popover__icon{display:flex;flex-shrink:0;align-items:center;justify-content:center;width:20px;height:20px;margin-top:2px;color:var(--ax-sys-color-text-neutral-600);font-size:14px}.task-popover .task-popover__icon i{display:block}.task-popover .task-popover__icon--priority[data-priority=urgent]{color:var(--ax-sys-color-danger)}.task-popover .task-popover__icon--priority[data-priority=high]{color:var(--ax-sys-color-warning)}.task-popover .task-popover__icon--priority[data-priority=normal]{color:rgb(var(--ax-sys-color-secondary-500))}.task-popover .task-popover__icon--priority[data-priority=low]{color:var(--ax-sys-color-text-neutral-500)}.task-popover .task-popover__info-content{display:flex;min-width:0px;flex:1;align-items:center}.task-popover .task-popover__info-text{font-size:14px;line-height:1.5;color:var(--ax-sys-color-text-primary);word-wrap:break-word}.task-popover .task-popover__priority{--tw-font-weight: var(--font-weight-medium, 500);font-weight:var(--font-weight-medium, 500);text-transform:capitalize}.task-popover .task-popover__priority[data-priority=urgent]{color:var(--ax-sys-color-danger)}.task-popover .task-popover__priority[data-priority=high]{color:var(--ax-sys-color-warning)}.task-popover .task-popover__priority[data-priority=normal]{color:rgb(var(--ax-sys-color-secondary-500))}.task-popover .task-popover__priority[data-priority=low]{color:var(--ax-sys-color-text-neutral-600)}.task-popover .task-popover__actions{display:flex;flex-direction:column;padding:12px 20px 16px;border-top:1px solid var(--ax-sys-color-border);gap:8px;background:var(--ax-sys-color-lighter-surface)}.task-popover .task-popover__actions-group{display:flex;flex-wrap:wrap;justify-content:flex-end;gap:8px}@property --tw-leading{syntax: \"*\"; inherits: false;}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-leading: initial;--tw-font-weight: initial;--tw-border-style: solid}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i1.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "component", type: i1.AXButtonItemComponent, selector: "ax-button-item", inputs: ["color", "disabled", "text", "selected", "divided", "data", "name"], outputs: ["onClick", "onFocus", "onBlur", "disabledChange"] }, { kind: "component", type: i1.AXButtonItemListComponent, selector: "ax-button-item-list", inputs: ["items", "closeParentOnClick", "lockOnLoading"], outputs: ["onItemClick"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i2.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: i2.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXDropdownModule }, { kind: "component", type: i3.AXDropdownPanelComponent, selector: "ax-dropdown-panel", inputs: ["isOpen", "fitParent", "dropdownWidth", "position", "placement", "_target", "adaptivityEnabled"], outputs: ["onOpened", "onClosed"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "pipe", type: i5.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskBoardDefaultTaskPopoverComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-task-board-default-task-popover', template: `
+    @if (task().description) {
+      <p class="task-popover__description">{{ task().description }}</p>
+    }
+
+    <div class="task-popover__content">
+      <div class="task-popover__info-item">
+        <div class="task-popover__icon">
+          <i class="fa-light fa-clock"></i>
+        </div>
+        <div class="task-popover__info-content">
+          <span class="task-popover__info-text">{{ formatDateRange(task()) }}</span>
+        </div>
+      </div>
+
+      @if (task().status) {
+        <div class="task-popover__info-item">
+          <div class="task-popover__icon">
+            <i class="fa-light fa-flag"></i>
+          </div>
+          <div class="task-popover__info-content">
+            <span class="task-popover__info-text">{{ task().status.title }}</span>
+          </div>
+        </div>
+      }
+
+      @if (task().assignee) {
+        <div class="task-popover__info-item">
+          <div class="task-popover__icon">
+            <i class="fa-light fa-user"></i>
+          </div>
+          <div class="task-popover__info-content">
+            <span class="task-popover__info-text">{{
+              task().assignee?.fullName || task().assignee?.username || 'Unassigned'
+            }}</span>
+          </div>
+        </div>
+      }
+
+      @if (task().priority) {
+        <div class="task-popover__info-item">
+          <div class="task-popover__icon task-popover__icon--priority" [attr.data-priority]="task().priority">
+            <i class="fa-light fa-exclamation-circle"></i>
+          </div>
+          <div class="task-popover__info-content">
+            <span class="task-popover__info-text task-popover__priority" [attr.data-priority]="task().priority">
+              {{ task().priority }}
+            </span>
+          </div>
+        </div>
+      }
+    </div>
+
+    @if (taskActions().length > 0) {
+      <div class="task-popover__actions">
+        <div class="task-popover__actions-group">
+          @if (primaryActions().length > 0) {
+            @for (action of primaryActions(); track action.name || action.title) {
+              <ax-button
+                [look]="'solid'"
+                [color]="getActionColor(action)"
+                (onClick)="executeAction(action)"
+                [disabled]="action.disabled === true"
+                [text]="(action.title | translate | async)!"
+              >
+                @if (action.icon) {
+                  <ax-prefix>
+                    <ax-icon>
+                      <i [class]="action.icon"></i>
+                    </ax-icon>
+                  </ax-prefix>
+                }
+              </ax-button>
+            }
+          }
+
+          @if (secondaryActions().length > 0) {
+            <ax-button [look]="'blank'">
+              <ax-prefix>
+                <ax-icon icon="fa-light fa-ellipsis-vertical"></ax-icon>
+              </ax-prefix>
+              <ax-dropdown-panel>
+                <ax-button-item-list>
+                  @for (action of secondaryActions(); track action.name || action.title) {
+                    <ax-button-item
+                      [text]="(action.title | translate | async)!"
+                      [disabled]="action.disabled === true"
+                      (onClick)="executeAction(action)"
+                    >
+                      @if (action.icon) {
+                        <ax-prefix>
+                          <ax-icon>
+                            <i [class]="action.icon"></i>
+                          </ax-icon>
+                        </ax-prefix>
+                      }
+                    </ax-button-item>
+                  }
+                </ax-button-item-list>
+              </ax-dropdown-panel>
+            </ax-button>
+          }
+        </div>
+      </div>
+    }
+  `, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, imports: [CommonModule, AXButtonModule, AXDecoratorModule, AXDropdownModule, AXTranslationModule], styles: ["@layer properties;.task-popover{display:flex;flex-direction:column;overflow:hidden;background:rgba(var(--ax-sys-color-lightest-surface));border-radius:12px;min-width:280px;max-width:420px}.task-popover .task-popover__header{padding:20px 20px 16px;border-bottom:1px solid var(--ax-sys-color-border);background:linear-gradient(to bottom,var(--ax-sys-color-lightest-surface),var(--ax-sys-color-lighter-surface))}.task-popover .task-popover__title-section{display:flex;flex-direction:column;gap:8px}.task-popover .task-popover__title-row{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}.task-popover .task-popover__title{margin:0;min-width:0px;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;--tw-leading: var(--leading-snug, 1.375);line-height:var(--leading-snug, 1.375);--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600);font-size:18px;color:var(--ax-sys-color-text-primary)}.task-popover .task-popover__close-btn{display:flex;flex-shrink:0;cursor:pointer;align-items:center;justify-content:center;border-style:var(--tw-border-style);border-width:0px;background:none;padding:4px;color:var(--ax-sys-color-text-neutral-600);transition:color .2s ease;border-radius:4px}.task-popover .task-popover__close-btn:hover{color:var(--ax-sys-color-text-primary);background:var(--ax-sys-color-lighter-surface)}.task-popover .task-popover__close-btn:active{background:var(--ax-sys-color-light-surface)}.task-popover .task-popover__close-btn ax-icon{display:block;width:16px;height:16px}.task-popover .task-popover__body{display:flex;flex-direction:column}.task-popover .task-popover__description{margin:0;overflow:hidden;text-overflow:ellipsis;font-size:14px;line-height:1.5;color:var(--ax-sys-color-text-secondary);padding:0 20px 12px;display:-webkit-box;-webkit-line-clamp:3;line-clamp:3;-webkit-box-orient:vertical}.task-popover .task-popover__content{display:flex;flex:1;flex-direction:column;padding:16px 20px;gap:12px}.task-popover .task-popover__info-item{display:flex;align-items:flex-start;gap:12px;min-height:24px}.task-popover .task-popover__icon{display:flex;flex-shrink:0;align-items:center;justify-content:center;width:20px;height:20px;margin-top:2px;color:var(--ax-sys-color-text-neutral-600);font-size:14px}.task-popover .task-popover__icon i{display:block}.task-popover .task-popover__icon--priority[data-priority=urgent]{color:var(--ax-sys-color-danger)}.task-popover .task-popover__icon--priority[data-priority=high]{color:var(--ax-sys-color-warning)}.task-popover .task-popover__icon--priority[data-priority=normal]{color:rgb(var(--ax-sys-color-secondary-500))}.task-popover .task-popover__icon--priority[data-priority=low]{color:var(--ax-sys-color-text-neutral-500)}.task-popover .task-popover__info-content{display:flex;min-width:0px;flex:1;align-items:center}.task-popover .task-popover__info-text{font-size:14px;line-height:1.5;color:var(--ax-sys-color-text-primary);word-wrap:break-word}.task-popover .task-popover__priority{--tw-font-weight: var(--font-weight-medium, 500);font-weight:var(--font-weight-medium, 500);text-transform:capitalize}.task-popover .task-popover__priority[data-priority=urgent]{color:var(--ax-sys-color-danger)}.task-popover .task-popover__priority[data-priority=high]{color:var(--ax-sys-color-warning)}.task-popover .task-popover__priority[data-priority=normal]{color:rgb(var(--ax-sys-color-secondary-500))}.task-popover .task-popover__priority[data-priority=low]{color:var(--ax-sys-color-text-neutral-600)}.task-popover .task-popover__actions{display:flex;flex-direction:column;padding:12px 20px 16px;border-top:1px solid var(--ax-sys-color-border);gap:8px;background:var(--ax-sys-color-lighter-surface)}.task-popover .task-popover__actions-group{display:flex;flex-wrap:wrap;justify-content:flex-end;gap:8px}@property --tw-leading{syntax: \"*\"; inherits: false;}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-leading: initial;--tw-font-weight: initial;--tw-border-style: solid}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }], ctorParameters: () => [], propDecorators: { task: [{ type: i0.Input, args: [{ isSignal: true, alias: "task", required: true }] }] } });
+/**
+ * Resolves the popover component for a task: provider custom component or the default task popover.
+ */
+async function resolveTaskPopoverComponent(task, taskBoardService) {
+    const defaultType = AXMTaskBoardDefaultTaskPopoverComponent;
+    if (!task.provider) {
+        return defaultType;
+    }
+    const provider = taskBoardService.getProvider(task.provider);
+    if (!provider) {
+        return defaultType;
+    }
+    const componentGetter = provider.getComponent?.();
+    if (!componentGetter) {
+        return defaultType;
+    }
+    try {
+        if (typeof componentGetter !== 'function') {
+            return defaultType;
+        }
+        let result;
+        try {
+            result = componentGetter();
+        }
+        catch {
+            return componentGetter;
+        }
+        if (result instanceof Promise) {
+            return await result;
+        }
+        if (result) {
+            return result;
+        }
+        return componentGetter;
+    }
+    catch (error) {
+        console.error('[TaskPopover] Failed to load custom task popover component:', error);
+        return defaultType;
+    }
+}
+
+/** Width for a single icon-only row action column. */
+const TASK_BOARD_GRID_ROW_ACTION_COLUMN_WIDTH = '70px';
+/** Icon-only command that opens the task details popover. */
+const TASK_BOARD_GRID_ROW_VIEW_ACTION = {
+    name: 'view',
+    text: '@task-management:task-board.grid-headers.action-view',
+    icon: 'fa-light fa-ellipsis-vertical',
+    iconOnly: true,
+    look: 'blank',
+};
+const TASK_BOARD_GRID_ROW_ACTION_ITEMS = [TASK_BOARD_GRID_ROW_VIEW_ACTION];
+
+function taskParamToDisplayString(translationService, value) {
+    if (value == null) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value.trim();
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (typeof value === 'object') {
+        const resolved = translationService.resolve(value);
+        return resolved?.trim() ?? '';
+    }
+    return String(value).trim();
+}
+const TASK_I18N_DATE_KEYS = new Set([
+    'startDate',
+    'endDate',
+    'effectiveDate',
+    'dueDate',
+    'occurredDate',
+]);
+function isDateLikeString(value) {
+    return /^\d{4}-\d{2}-\d{2}(?:T|$)/.test(value.trim());
+}
+function parseDateOnlyString(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(value.trim());
+    if (!match) {
+        return null;
+    }
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (!year || !month || !day) {
+        return null;
+    }
+    return new Date(year, month - 1, day);
+}
+/** Resolves MLS and formats dates at display time so task labels react to locale changes. */
+async function formatTaskI18nParamsForTranslate(raw, translationService, formatService, settingsService) {
+    if (!raw) {
+        return {};
+    }
+    const format = await settingsService.get(AXPRegionalSetting.ShortDate);
+    const params = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (value == null || value === '') {
+            continue;
+        }
+        if (TASK_I18N_DATE_KEYS.has(key) &&
+            (value instanceof Date || (typeof value === 'string' && isDateLikeString(value)))) {
+            const date = value instanceof Date ? value : parseDateOnlyString(value) ?? new Date(value);
+            if (!Number.isNaN(date.getTime())) {
+                const formatted = formatService.format(date, 'date', { format });
+                const text = typeof formatted === 'string' ? formatted : String(formatted ?? '');
+                if (text) {
+                    params[key] = text;
+                }
+            }
+            continue;
+        }
+        const text = taskParamToDisplayString(translationService, value);
+        if (text) {
+            params[key] = text;
+        }
+    }
+    return params;
+}
+function getTaskTranslationKey(task, field) {
+    const data = task.data;
+    const key = field === 'title' ? data?.titleKey : data?.descriptionKey;
+    if (key?.trim().startsWith('@')) {
+        return key.trim();
+    }
+    const payloadKey = field === 'title' ? data?.payload?.title : data?.payload?.description;
+    if (payloadKey?.trim().startsWith('@')) {
+        return payloadKey.trim();
+    }
+    const fallback = field === 'title' ? task.title : task.description;
+    return fallback?.trim().startsWith('@') ? fallback.trim() : undefined;
+}
+/** Resolves scheduler/kanban labels; popovers should use the translate pipe with {@link getTaskTranslationKey}. */
+async function resolveTaskBoardSchedulerLabels(tasks, translationService, formatService, settingsService) {
+    return Promise.all(tasks.map(async (task) => {
+        const titleKey = getTaskTranslationKey(task, 'title');
+        const descriptionKey = getTaskTranslationKey(task, 'description');
+        const rawParams = get(task.data, 'taskI18nParams');
+        const params = await formatTaskI18nParamsForTranslate(rawParams, translationService, formatService, settingsService);
+        return {
+            ...task,
+            ...(titleKey ? { title: await translationService.translateAsync(titleKey, { params }) } : {}),
+            ...(descriptionKey
+                ? { description: await translationService.translateAsync(descriptionKey, { params }) }
+                : {}),
+        };
+    }));
+}
+function enrichTaskBoardTasks(tasks, colorBy, dueStatusProviderService) {
+    return tasks.map((task) => {
+        const withDueStatus = dueStatusProviderService.attachDueStatusToTask(task);
+        const accentClass = buildTaskSurfaceCssClass(resolveTaskBoardAccentColor(withDueStatus, colorBy));
+        const calendarPlacement = resolveTaskBoardCalendarPlacement(withDueStatus);
+        return {
+            ...withDueStatus,
+            ...calendarPlacement,
+            cssClass: accentClass,
+        };
+    });
+}
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Component   ----
+class AXMTaskBoardTaskPopoverShellComponent {
+    constructor() {
+        this.task = input.required(/* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "task" }] : /* istanbul ignore next */ []));
+        this.bodyComponent = input.required(/* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "bodyComponent" }] : /* istanbul ignore next */ []));
+        this.requestClose = input.required(/* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "requestClose" }] : /* istanbul ignore next */ []));
+        this.localeService = inject(AXLocaleService);
+        this.formatService = inject(AXFormatService);
+        this.settingsService = inject(AXPSettingsService);
+        this.translationService = inject(AXTranslationService);
+        this.i18nParams = signal({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "i18nParams" }] : /* istanbul ignore next */ []));
+        this.titleKey = computed(() => getTaskTranslationKey(this.task(), 'title'), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "titleKey" }] : /* istanbul ignore next */ []));
+        this.bodyInputs = computed(() => ({ task: this.task() }), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "bodyInputs" }] : /* istanbul ignore next */ []));
+        this.i18nParamsEffect = effect(() => {
+            const task = this.task();
+            void this.localeService.activeProfile().localeInfo?.code;
+            const raw = get(task.data, 'taskI18nParams');
+            void formatTaskI18nParamsForTranslate(raw, this.translationService, this.formatService, this.settingsService).then((params) => this.i18nParams.set(params));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "i18nParamsEffect" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskBoardTaskPopoverShellComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXMTaskBoardTaskPopoverShellComponent, isStandalone: true, selector: "axm-task-board-task-popover-shell", inputs: { task: { classPropertyName: "task", publicName: "task", isSignal: true, isRequired: true, transformFunction: null }, bodyComponent: { classPropertyName: "bodyComponent", publicName: "bodyComponent", isSignal: true, isRequired: true, transformFunction: null }, requestClose: { classPropertyName: "requestClose", publicName: "requestClose", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `
+    <div class="task-popover">
+      <div class="task-popover__header">
+        <div class="task-popover__title-section">
+          <div class="task-popover__title-row">
+            <h3 class="task-popover__title">
+              @if (titleKey(); as key) {
+                {{ key | translate: { params: i18nParams() } | async }}
+              } @else {
+                {{ task().title }}
+              }
+            </h3>
+            <button type="button" class="task-popover__close-btn" (click)="requestClose()()" aria-label="Close">
+              <ax-icon class="ax-icon ax-icon-close"></ax-icon>
+            </button>
+          </div>
+        </div>
+      </div>
+      <div class="task-popover__body">
+        @if (bodyComponent()) {
+          <ng-container *ngComponentOutlet="bodyComponent()!; inputs: bodyInputs()" />
+        }
+      </div>
+    </div>
+  `, isInline: true, styles: ["@layer properties;.task-popover{display:flex;flex-direction:column;overflow:hidden;background:rgba(var(--ax-sys-color-lightest-surface));border-radius:12px;min-width:280px;max-width:420px}.task-popover .task-popover__header{padding:20px 20px 16px;border-bottom:1px solid var(--ax-sys-color-border);background:linear-gradient(to bottom,var(--ax-sys-color-lightest-surface),var(--ax-sys-color-lighter-surface))}.task-popover .task-popover__title-section{display:flex;flex-direction:column;gap:8px}.task-popover .task-popover__title-row{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}.task-popover .task-popover__title{margin:0;min-width:0px;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;--tw-leading: var(--leading-snug, 1.375);line-height:var(--leading-snug, 1.375);--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600);font-size:18px;color:var(--ax-sys-color-text-primary)}.task-popover .task-popover__close-btn{display:flex;flex-shrink:0;cursor:pointer;align-items:center;justify-content:center;border-style:var(--tw-border-style);border-width:0px;background:none;padding:4px;color:var(--ax-sys-color-text-neutral-600);transition:color .2s ease;border-radius:4px}.task-popover .task-popover__close-btn:hover{color:var(--ax-sys-color-text-primary);background:var(--ax-sys-color-lighter-surface)}.task-popover .task-popover__close-btn:active{background:var(--ax-sys-color-light-surface)}.task-popover .task-popover__close-btn ax-icon{display:block;width:16px;height:16px}.task-popover .task-popover__body{display:flex;flex-direction:column}.task-popover .task-popover__description{margin:0;overflow:hidden;text-overflow:ellipsis;font-size:14px;line-height:1.5;color:var(--ax-sys-color-text-secondary);padding:0 20px 12px;display:-webkit-box;-webkit-line-clamp:3;line-clamp:3;-webkit-box-orient:vertical}.task-popover .task-popover__content{display:flex;flex:1;flex-direction:column;padding:16px 20px;gap:12px}.task-popover .task-popover__info-item{display:flex;align-items:flex-start;gap:12px;min-height:24px}.task-popover .task-popover__icon{display:flex;flex-shrink:0;align-items:center;justify-content:center;width:20px;height:20px;margin-top:2px;color:var(--ax-sys-color-text-neutral-600);font-size:14px}.task-popover .task-popover__icon i{display:block}.task-popover .task-popover__icon--priority[data-priority=urgent]{color:var(--ax-sys-color-danger)}.task-popover .task-popover__icon--priority[data-priority=high]{color:var(--ax-sys-color-warning)}.task-popover .task-popover__icon--priority[data-priority=normal]{color:rgb(var(--ax-sys-color-secondary-500))}.task-popover .task-popover__icon--priority[data-priority=low]{color:var(--ax-sys-color-text-neutral-500)}.task-popover .task-popover__info-content{display:flex;min-width:0px;flex:1;align-items:center}.task-popover .task-popover__info-text{font-size:14px;line-height:1.5;color:var(--ax-sys-color-text-primary);word-wrap:break-word}.task-popover .task-popover__priority{--tw-font-weight: var(--font-weight-medium, 500);font-weight:var(--font-weight-medium, 500);text-transform:capitalize}.task-popover .task-popover__priority[data-priority=urgent]{color:var(--ax-sys-color-danger)}.task-popover .task-popover__priority[data-priority=high]{color:var(--ax-sys-color-warning)}.task-popover .task-popover__priority[data-priority=normal]{color:rgb(var(--ax-sys-color-secondary-500))}.task-popover .task-popover__priority[data-priority=low]{color:var(--ax-sys-color-text-neutral-600)}.task-popover .task-popover__actions{display:flex;flex-direction:column;padding:12px 20px 16px;border-top:1px solid var(--ax-sys-color-border);gap:8px;background:var(--ax-sys-color-lighter-surface)}.task-popover .task-popover__actions-group{display:flex;flex-wrap:wrap;justify-content:flex-end;gap:8px}@property --tw-leading{syntax: \"*\"; inherits: false;}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-leading: initial;--tw-font-weight: initial;--tw-border-style: solid}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i2.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "pipe", type: i5.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskBoardTaskPopoverShellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-task-board-task-popover-shell', template: `
+    <div class="task-popover">
+      <div class="task-popover__header">
+        <div class="task-popover__title-section">
+          <div class="task-popover__title-row">
+            <h3 class="task-popover__title">
+              @if (titleKey(); as key) {
+                {{ key | translate: { params: i18nParams() } | async }}
+              } @else {
+                {{ task().title }}
+              }
+            </h3>
+            <button type="button" class="task-popover__close-btn" (click)="requestClose()()" aria-label="Close">
+              <ax-icon class="ax-icon ax-icon-close"></ax-icon>
+            </button>
+          </div>
+        </div>
+      </div>
+      <div class="task-popover__body">
+        @if (bodyComponent()) {
+          <ng-container *ngComponentOutlet="bodyComponent()!; inputs: bodyInputs()" />
+        }
+      </div>
+    </div>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, imports: [CommonModule, AXDecoratorModule, AXTranslationModule], styles: ["@layer properties;.task-popover{display:flex;flex-direction:column;overflow:hidden;background:rgba(var(--ax-sys-color-lightest-surface));border-radius:12px;min-width:280px;max-width:420px}.task-popover .task-popover__header{padding:20px 20px 16px;border-bottom:1px solid var(--ax-sys-color-border);background:linear-gradient(to bottom,var(--ax-sys-color-lightest-surface),var(--ax-sys-color-lighter-surface))}.task-popover .task-popover__title-section{display:flex;flex-direction:column;gap:8px}.task-popover .task-popover__title-row{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}.task-popover .task-popover__title{margin:0;min-width:0px;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;--tw-leading: var(--leading-snug, 1.375);line-height:var(--leading-snug, 1.375);--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600);font-size:18px;color:var(--ax-sys-color-text-primary)}.task-popover .task-popover__close-btn{display:flex;flex-shrink:0;cursor:pointer;align-items:center;justify-content:center;border-style:var(--tw-border-style);border-width:0px;background:none;padding:4px;color:var(--ax-sys-color-text-neutral-600);transition:color .2s ease;border-radius:4px}.task-popover .task-popover__close-btn:hover{color:var(--ax-sys-color-text-primary);background:var(--ax-sys-color-lighter-surface)}.task-popover .task-popover__close-btn:active{background:var(--ax-sys-color-light-surface)}.task-popover .task-popover__close-btn ax-icon{display:block;width:16px;height:16px}.task-popover .task-popover__body{display:flex;flex-direction:column}.task-popover .task-popover__description{margin:0;overflow:hidden;text-overflow:ellipsis;font-size:14px;line-height:1.5;color:var(--ax-sys-color-text-secondary);padding:0 20px 12px;display:-webkit-box;-webkit-line-clamp:3;line-clamp:3;-webkit-box-orient:vertical}.task-popover .task-popover__content{display:flex;flex:1;flex-direction:column;padding:16px 20px;gap:12px}.task-popover .task-popover__info-item{display:flex;align-items:flex-start;gap:12px;min-height:24px}.task-popover .task-popover__icon{display:flex;flex-shrink:0;align-items:center;justify-content:center;width:20px;height:20px;margin-top:2px;color:var(--ax-sys-color-text-neutral-600);font-size:14px}.task-popover .task-popover__icon i{display:block}.task-popover .task-popover__icon--priority[data-priority=urgent]{color:var(--ax-sys-color-danger)}.task-popover .task-popover__icon--priority[data-priority=high]{color:var(--ax-sys-color-warning)}.task-popover .task-popover__icon--priority[data-priority=normal]{color:rgb(var(--ax-sys-color-secondary-500))}.task-popover .task-popover__icon--priority[data-priority=low]{color:var(--ax-sys-color-text-neutral-500)}.task-popover .task-popover__info-content{display:flex;min-width:0px;flex:1;align-items:center}.task-popover .task-popover__info-text{font-size:14px;line-height:1.5;color:var(--ax-sys-color-text-primary);word-wrap:break-word}.task-popover .task-popover__priority{--tw-font-weight: var(--font-weight-medium, 500);font-weight:var(--font-weight-medium, 500);text-transform:capitalize}.task-popover .task-popover__priority[data-priority=urgent]{color:var(--ax-sys-color-danger)}.task-popover .task-popover__priority[data-priority=high]{color:var(--ax-sys-color-warning)}.task-popover .task-popover__priority[data-priority=normal]{color:rgb(var(--ax-sys-color-secondary-500))}.task-popover .task-popover__priority[data-priority=low]{color:var(--ax-sys-color-text-neutral-600)}.task-popover .task-popover__actions{display:flex;flex-direction:column;padding:12px 20px 16px;border-top:1px solid var(--ax-sys-color-border);gap:8px;background:var(--ax-sys-color-lighter-surface)}.task-popover .task-popover__actions-group{display:flex;flex-wrap:wrap;justify-content:flex-end;gap:8px}@property --tw-leading{syntax: \"*\"; inherits: false;}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-leading: initial;--tw-font-weight: initial;--tw-border-style: solid}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }], propDecorators: { task: [{ type: i0.Input, args: [{ isSignal: true, alias: "task", required: true }] }], bodyComponent: [{ type: i0.Input, args: [{ isSignal: true, alias: "bodyComponent", required: true }] }], requestClose: [{ type: i0.Input, args: [{ isSignal: true, alias: "requestClose", required: true }] }] } });
+
+//#endregion
+//#region ----   Service   ----
+/**
+ * Opens task-board task popovers via {@link AXOverlayService}, matching {@link AXPopoverComponent} anchor positioning.
+ */
+class AXMTaskBoardTaskPopoverOverlayService {
+    constructor() {
+        //#region ----   Services & Dependencies   ----
+        this.overlayService = inject(AXOverlayService);
+        this.taskBoardService = inject(AXPTaskBoardService);
+        this.platform = inject(AXPlatform);
+        this.document = inject(DOCUMENT);
+        //#endregion
+        //#region ----   Private Properties   ----
+        this.overlayRef = null;
+        this.shellRef = null;
+        this.activeTask = null;
+        this.anchorElement = null;
+        this.outsideClickHandler = null;
+        this.keydownHandler = null;
+    }
+    //#endregion
+    //#region ----   Public Methods   ----
+    getActiveTask() {
+        return this.activeTask;
+    }
+    isOpen() {
+        return this.overlayRef !== null;
+    }
+    async open(options) {
+        const anchorElement = this.resolveAnchorElement(options.anchor);
+        if (!anchorElement) {
+            return;
+        }
+        this.close();
+        const bodyComponent = await resolveTaskPopoverComponent(options.task, this.taskBoardService);
+        this.activeTask = options.task;
+        this.anchorElement = anchorElement;
+        const panelClasses = ['animate-fadeIn', 'animate-faster'];
+        if (this.platform.isDark()) {
+            panelClasses.push('ax-dark');
+        }
+        const requestClose = () => {
+            this.close();
+        };
+        try {
+            const ref = await this.overlayService.create(AXMTaskBoardTaskPopoverShellComponent, {
+                centered: false,
+                width: 'fit-content',
+                actionSheetStyle: options.adaptivityEnabled ?? true,
+                panelClass: panelClasses,
+                backdrop: {
+                    enabled: false,
+                    background: false,
+                    closeOnClick: false,
+                },
+                anchorOptions: {
+                    anchor: anchorElement,
+                    placement: options.placement ?? 'bottom-start',
+                    offsetX: options.offsetX ?? 8,
+                    offsetY: options.offsetY ?? 8,
+                    autoFlip: options.autoFlip ?? true,
+                },
+                inputs: {
+                    task: options.task,
+                    bodyComponent,
+                    requestClose,
+                },
+                onDispose: () => {
+                    this.handleOverlayDisposed();
+                },
+            });
+            this.overlayRef = ref;
+            this.shellRef = ref.instance;
+            setTimeout(() => {
+                ref.updatePosition();
+                this.bindDismissHandlers(ref.overlayElement, anchorElement);
+            }, 0);
+        }
+        catch (error) {
+            console.error('[TaskBoardTaskPopover] Failed to open overlay:', error);
+            this.handleOverlayDisposed();
+        }
+    }
+    async refreshTask(task) {
+        if (!this.overlayRef || !this.shellRef || !this.activeTask || this.activeTask.id !== task.id) {
+            return;
+        }
+        const bodyComponent = await resolveTaskPopoverComponent(task, this.taskBoardService);
+        this.activeTask = task;
+        this.shellRef.setInput('task', task);
+        this.shellRef.setInput('bodyComponent', bodyComponent);
+    }
+    close() {
+        this.removeDismissHandlers();
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+            this.overlayRef = null;
+        }
+        this.shellRef = null;
+        this.activeTask = null;
+        this.anchorElement = null;
+    }
+    //#endregion
+    //#region ----   Utility Methods   ----
+    /**
+     * Normalizes an anchor to a host {@link HTMLElement} for {@link AXOverlayService}.
+     */
+    resolveAnchorElement(anchor) {
+        if (anchor instanceof ElementRef) {
+            return anchor.nativeElement;
+        }
+        if (anchor instanceof HTMLElement) {
+            return anchor;
+        }
+        const hostCandidate = anchor;
+        if (typeof hostCandidate.getHostElement === 'function') {
+            return hostCandidate.getHostElement();
+        }
+        return anchor;
+    }
+    /**
+     * Resolves an overlay anchor from a grid command-column click.
+     */
+    resolveAnchorFromCommandClick(event) {
+        if (event.htmlElement instanceof HTMLElement) {
+            return event.htmlElement;
+        }
+        const nativeEvent = event.nativeEvent;
+        if (nativeEvent instanceof MouseEvent) {
+            return this.resolveAnchor(nativeEvent);
+        }
+        const nestedClick = nativeEvent;
+        if (nestedClick?.htmlElement instanceof HTMLElement) {
+            return nestedClick.htmlElement;
+        }
+        if (nestedClick?.component && typeof nestedClick.component.getHostElement === 'function') {
+            return nestedClick.component.getHostElement();
+        }
+        return this.resolveAnchor(nestedClick?.nativeEvent);
+    }
+    /**
+     * Resolves an overlay anchor from a native click (e.g. command button in a data table cell).
+     */
+    resolveAnchor(nativeEvent, htmlElement) {
+        if (htmlElement) {
+            return htmlElement;
+        }
+        const target = (nativeEvent?.currentTarget ?? nativeEvent?.target);
+        if (!target) {
+            return undefined;
+        }
+        const cell = target.closest?.('td');
+        const cellTrigger = cell?.querySelector('ax-button, button');
+        if (cellTrigger instanceof HTMLElement) {
+            return cellTrigger;
+        }
+        const buttonHost = target.closest?.('ax-button');
+        if (buttonHost instanceof HTMLElement) {
+            return buttonHost;
+        }
+        let element = target;
+        for (let depth = 0; element && depth < 12; depth++) {
+            if (element.tagName.toLowerCase() === 'ax-button' && element instanceof HTMLElement) {
+                return element;
+            }
+            element = element.parentElement;
+        }
+        return target instanceof HTMLElement ? target : undefined;
+    }
+    bindDismissHandlers(overlayElement, anchor) {
+        this.removeDismissHandlers();
+        this.keydownHandler = (event) => {
+            if (event.key === 'Escape') {
+                this.close();
+            }
+        };
+        this.document.addEventListener('keydown', this.keydownHandler);
+        this.outsideClickHandler = (event) => {
+            const target = event.target;
+            if (!target || !overlayElement) {
+                return;
+            }
+            if (this.isInsideTaskPopoverInteractiveSurface(target, overlayElement, anchor)) {
+                return;
+            }
+            this.close();
+        };
+        this.document.addEventListener('mousedown', this.outsideClickHandler);
+    }
+    /** Dropdown menus render outside the popover overlay; ignore those clicks when dismissing. */
+    isInsideTaskPopoverInteractiveSurface(target, overlayElement, anchor) {
+        if (anchor.contains(target) || overlayElement.contains(target)) {
+            return true;
+        }
+        return Boolean(target.closest('ax-dropdown-panel, ax-button-item-list, ax-button-item, ax-dropdown-button, .ax-dropdown-panel'));
+    }
+    removeDismissHandlers() {
+        if (this.keydownHandler) {
+            this.document.removeEventListener('keydown', this.keydownHandler);
+            this.keydownHandler = null;
+        }
+        if (this.outsideClickHandler) {
+            this.document.removeEventListener('mousedown', this.outsideClickHandler);
+            this.outsideClickHandler = null;
+        }
+    }
+    handleOverlayDisposed() {
+        this.removeDismissHandlers();
+        this.overlayRef = null;
+        this.shellRef = null;
+        this.activeTask = null;
+        this.anchorElement = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskBoardTaskPopoverOverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskBoardTaskPopoverOverlayService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskBoardTaskPopoverOverlayService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+function createAppRoute() {
+    const config = inject(AXP_ENTITY_CONFIG_TOKEN);
+    return {
+        path: ':app/TaskManagement/task-board',
+        canActivate: [...AXP_PROTECTED_ROUTE_GUARDS],
+        data: { rootLayout: true },
+        loadComponent: () => {
+            return config.viewers.root();
+        },
+        children: [
+            {
+                path: '',
+                loadComponent: () => import('./acorex-platform-module-task-management-client-task-board.page-8I8H2pFq.mjs').then((c) => c.AXMTaskBoardPage),
+            },
+        ],
+    };
+}
+function routesFactory() {
+    const routes = [createAppRoute()];
+    return routes;
+}
+class AXPTaskBoardModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardModule, imports: [AXPRuntimeModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardModule, providers: [
+            provideCommandSetups([
+                {
+                    key: AXPTaskManagementCommandKeys.TaskBoard.ResetFiltersAssignToCurrentUser,
+                    command: () => Promise.resolve().then(function () { return resetFiltersAssignToCurrentUser_command; }).then((c) => c.ResetTaskBoardFiltersAssignToCurrentUserCommand),
+                },
+            ]),
+            {
+                provide: AXP_HOME_PAGES,
+                multi: true,
+                useFactory: () => [
+                    {
+                        key: 'task-board',
+                        title: 'Task Board',
+                        route: createAppRoute(),
+                    },
+                ],
+            },
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: routesFactory,
+            },
+            provideQuerySetups([
+                {
+                    key: AXMTaskManagementQueryKeys.ListTaskTypes,
+                    loader: () => import('./acorex-platform-module-task-management-client-list-task-types.query-CKLUPrBU.mjs').then((c) => c.AXMListTaskTypesQuery),
+                },
+                {
+                    key: AXMTaskManagementQueryKeys.TaskBoardAssignees,
+                    loader: () => import('./acorex-platform-module-task-management-client-list-task-board-assignees.query-Ci8_D4Vs.mjs').then((c) => c.AXMListTaskBoardAssigneesQuery),
+                },
+                {
+                    key: AXMTaskManagementQueryKeys.TaskBoardReporters,
+                    loader: () => import('./acorex-platform-module-task-management-client-list-task-board-reporters.query-C3NAYa9b.mjs').then((c) => c.AXMListTaskBoardReportersQuery),
+                },
+            ]),
+        ], imports: [AXPRuntimeModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [AXPRuntimeModule],
+                    providers: [
+                        provideCommandSetups([
+                            {
+                                key: AXPTaskManagementCommandKeys.TaskBoard.ResetFiltersAssignToCurrentUser,
+                                command: () => Promise.resolve().then(function () { return resetFiltersAssignToCurrentUser_command; }).then((c) => c.ResetTaskBoardFiltersAssignToCurrentUserCommand),
+                            },
+                        ]),
+                        {
+                            provide: AXP_HOME_PAGES,
+                            multi: true,
+                            useFactory: () => [
+                                {
+                                    key: 'task-board',
+                                    title: 'Task Board',
+                                    route: createAppRoute(),
+                                },
+                            ],
+                        },
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: routesFactory,
+                        },
+                        provideQuerySetups([
+                            {
+                                key: AXMTaskManagementQueryKeys.ListTaskTypes,
+                                loader: () => import('./acorex-platform-module-task-management-client-list-task-types.query-CKLUPrBU.mjs').then((c) => c.AXMListTaskTypesQuery),
+                            },
+                            {
+                                key: AXMTaskManagementQueryKeys.TaskBoardAssignees,
+                                loader: () => import('./acorex-platform-module-task-management-client-list-task-board-assignees.query-Ci8_D4Vs.mjs').then((c) => c.AXMListTaskBoardAssigneesQuery),
+                            },
+                            {
+                                key: AXMTaskManagementQueryKeys.TaskBoardReporters,
+                                loader: () => import('./acorex-platform-module-task-management-client-list-task-board-reporters.query-C3NAYa9b.mjs').then((c) => c.AXMListTaskBoardReportersQuery),
+                            },
+                        ]),
+                    ],
+                }]
+        }] });
+
+/**
+ * Feeds the platform task board from persisted {@link TaskManagement.Task} rows.
+ */
+class AXPTaskManagementEntityTaskProvider extends AXPWorkflowTaskProvider {
+    constructor() {
+        super(...arguments);
+        this.entityService = inject(AXPEntityService);
+        this.calendarService = inject(AXCalendarService);
+        this.dueStatusProviderService = inject(AXPDueStatusProviderService);
+    }
+    getTitle() {
+        return Promise.resolve('Tasks');
+    }
+    getIcon() {
+        return Promise.resolve('fa-light fa-clipboard-check');
+    }
+    get name() {
+        return 'task-management.tasks';
+    }
+    async getTasks(options) {
+        const filters = [
+            { field: 'isArchived', operator: { type: 'equal' }, value: false },
+        ];
+        if (options?.subjectRefTypes?.length) {
+            filters.push({
+                field: 'subjectRef.type',
+                operator: { type: 'in' },
+                value: options.subjectRefTypes,
+            });
+        }
+        if (options?.subjectRefIds?.length) {
+            filters.push({
+                field: 'subjectRef.id',
+                operator: { type: 'in' },
+                value: options.subjectRefIds,
+            });
+        }
+        const requiresClientSideFiltering = Boolean(options?.range?.from && options.range.end) ||
+            (options?.priorities?.length ?? 0) > 0 ||
+            (options?.dueStatusKeys?.length ?? 0) > 0;
+        const page = await this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.task.name)
+            .data()
+            .query({
+            skip: requiresClientSideFiltering ? 0 : (options?.skip ?? 0),
+            take: requiresClientSideFiltering ? 1000 : Math.min(options?.take ?? 1000, 1000),
+            filter: { logic: 'and', filters },
+        });
+        const rows = (page.items ?? []);
+        let items = rows.map((row) => this.mapRowToTask(row));
+        if (options?.range?.from && options.range.end) {
+            items = filterTasksOverlappingRange(items, options.range);
+        }
+        if (options?.priorities?.length) {
+            items = items.filter((task) => matchesTaskPriorityFilter(task, options.priorities));
+        }
+        items = items.map((task) => this.dueStatusProviderService.attachDueStatusToTask(task));
+        if (options?.dueStatusKeys?.length) {
+            items = items.filter((task) => matchesTaskDueStatusFilter(task, options.dueStatusKeys));
+        }
+        const total = items.length;
+        const skip = options?.skip ?? 0;
+        const take = options?.take ?? total;
+        return { items: items.slice(skip, skip + take), total };
+    }
+    async updateTasks(tasksToUpdate) {
+        return tasksToUpdate;
+    }
+    async getStatuses() {
+        return [];
+    }
+    async getExtraFields() {
+        return [];
+    }
+    async executeCommand(command) {
+        return command.name === 'Entity:OpenDetails'
+            ? { success: true, kind: 'object', data: undefined }
+            : { success: false };
+    }
+    async getActions(task) {
+        if (!task?.id) {
+            return [];
+        }
+        return [
+            {
+                name: 'Entity:OpenDetails',
+                title: '@general:actions.view.title',
+                icon: 'fa-light fa-eye',
+                command: {
+                    name: 'Entity:OpenDetails',
+                    options: {
+                        entity: `${RootConfig.module.name}.${RootConfig.entities.task.name}`,
+                        id: task.id,
+                    },
+                },
+            },
+        ];
+    }
+    //#region ---- Mapping ----
+    mapRowToTask(row) {
+        const startDate = row.startDate ?? row.dueDate ?? this.calendarService.create(new Date()).date;
+        const endDate = row.dueDate ?? row.startDate ?? startDate;
+        const statusTitle = defaultTo(get(row, 'status.title'), 'Unknown');
+        const statusId = defaultTo(get(row, 'status.id'), row.statusId);
+        return {
+            id: row.id,
+            index: row.order ?? 0,
+            title: row.title,
+            description: row.description,
+            status: {
+                id: statusId,
+                title: statusTitle,
+                color: get(row, 'status.color'),
+            },
+            reporter: { id: 'system', type: 'user', fullName: 'System' },
+            startDate,
+            endDate,
+            priority: this.mapPriority(row.priority),
+            progress: row.progress,
+            tags: row.tags,
+            provider: this.name,
+            data: {
+                taskTypeId: row.taskTypeId,
+                subjectRef: row.subjectRef,
+                entityId: row.id,
+            },
+        };
+    }
+    mapPriority(priority) {
+        switch (priority) {
+            case 'low':
+                return 'low';
+            case 'medium':
+                return 'normal';
+            case 'high':
+                return 'high';
+            case 'critical':
+                return 'urgent';
+            default:
+                return undefined;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskManagementEntityTaskProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskManagementEntityTaskProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskManagementEntityTaskProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXPTaskBoardShortcutViewComponent extends AXPLayoutBaseWidgetComponent {
+    constructor() {
+        super(...arguments);
+        this.taskBoardService = inject(AXPTaskBoardService);
+        this.sessionService = inject(AXPSessionService);
+        this.tasksCount = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "tasksCount" }] : /* istanbul ignore next */ []));
+        this.assignee = computed(() => this.options()?.['assignee'] ?? [], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "assignee" }] : /* istanbul ignore next */ []));
+        this.priority = computed(() => this.options()?.['priority'] ?? [], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "priority" }] : /* istanbul ignore next */ []));
+        this.selectedTaskTypes = computed(() => this.options()?.['taskTypes'] ?? [], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedTaskTypes" }] : /* istanbul ignore next */ []));
+        this.dateRange = computed(() => this.options()?.['dateRange'] ?? { title: 'This Month', name: 'this-month' }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "dateRange" }] : /* istanbul ignore next */ []));
+        this.title = computed(() => {
+            const types = this.selectedTaskTypes()
+                .map((t) => t.title)
+                .join(', ');
+            return types === '' ? 'All Tasks' : types;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "title" }] : /* istanbul ignore next */ []));
+        this.queryParams = computed(() => {
+            const dateRange = this.dateRange().name;
+            const assignee = normalizeTaskBoardAssigneeIds(this.sessionService, this.assignee().map((a) => a.id)).map(String);
+            const priority = this.priority().map((p) => p.name);
+            const type = this.selectedTaskTypes().map((t) => t.name);
+            return { type, priority, assignee, dateRange };
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "queryParams" }] : /* istanbul ignore next */ []));
+        this.#taskCounter = effect(async () => {
+            const params = this.queryParams();
+            const range = this.taskBoardService.rangeCalculator(params.dateRange);
+            const options = {
+                range,
+                types: params.type,
+                priorities: params.priority,
+                assigneeIds: params.assignee,
+            };
+            this.taskBoardService.getTasks(options).then((t) => this.tasksCount.set(t.total));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#taskCounter" }] : /* istanbul ignore next */ []));
+    }
+    #taskCounter;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardShortcutViewComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.8", type: AXPTaskBoardShortcutViewComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: "<div class=\"flex flex-col gap-3 px-6 pt-3 pb-6 h-full\">\n  <h1 class=\"text-start text-lg font-medium truncate h-9\">{{ title() | translate | async }}</h1>\n  <div class=\"w-full h-full relative\">\n    <div class=\"flex flex-col gap-2 text-start\">\n      <h3 class=\"text-xl text-primary text-nowrap\">{{ dateRange().title | translate | async }}</h3>\n      <h1 class=\"text-6xl font-bold\">{{ tasksCount() }}</h1>\n    </div>\n    <a\n      [queryParams]=\"queryParams()\"\n      class=\"absolute bottom-0 right-0\"\n      [routerLink]=\"['/TaskManagement/task-board']\"\n    >\n      <ax-button [text]=\"'View all'\" [look]=\"'link'\" class=\"ax-sm\" [color]=\"'primary'\">\n        <ax-suffix> <ax-icon class=\"fa-solid fa-external-link\"></ax-icon> </ax-suffix>\n      </ax-button>\n    </a>\n  </div>\n</div>\n", styles: ["/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "component", type: AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "component", type: AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "directive", type: RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "browserUrl", "routerLink"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "pipe", type: i5.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardShortcutViewComponent, decorators: [{
+            type: Component,
+            args: [{ imports: [
+                        CommonModule,
+                        AXButtonComponent,
+                        AXDecoratorIconComponent,
+                        AXDecoratorGenericComponent,
+                        RouterLink,
+                        AXTranslationModule,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"flex flex-col gap-3 px-6 pt-3 pb-6 h-full\">\n  <h1 class=\"text-start text-lg font-medium truncate h-9\">{{ title() | translate | async }}</h1>\n  <div class=\"w-full h-full relative\">\n    <div class=\"flex flex-col gap-2 text-start\">\n      <h3 class=\"text-xl text-primary text-nowrap\">{{ dateRange().title | translate | async }}</h3>\n      <h1 class=\"text-6xl font-bold\">{{ tasksCount() }}</h1>\n    </div>\n    <a\n      [queryParams]=\"queryParams()\"\n      class=\"absolute bottom-0 right-0\"\n      [routerLink]=\"['/TaskManagement/task-board']\"\n    >\n      <ax-button [text]=\"'View all'\" [look]=\"'link'\" class=\"ax-sm\" [color]=\"'primary'\">\n        <ax-suffix> <ax-icon class=\"fa-solid fa-external-link\"></ax-icon> </ax-suffix>\n      </ax-button>\n    </a>\n  </div>\n</div>\n", styles: ["/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }] });
+
+var taskBoardShortcut_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPTaskBoardShortcutViewComponent: AXPTaskBoardShortcutViewComponent
+});
+
+/**
+ * Parent tab for task-management dashboard widgets in the widget gallery.
+ */
+const AXP_TASK_MANAGEMENT_DASHBOARD_WIDGET_CATEGORY = {
+    name: 'tasks',
+    order: 4,
+    title: '@task-management:dashboard-widgets.widget-picker-category.tasks',
+};
+
+const SUB = '@task-management:dashboard-widgets.widget-picker-sub-categories';
+//#region ---- Task dashboard widget picker sub-categories ----
+const AXP_TASK_MANAGEMENT_DASHBOARD_SUB_SHORTCUT = {
+    name: 'task-dashboard-shortcut',
+    order: 1,
+    title: `${SUB}.shortcut`,
+};
+const AXP_TASK_MANAGEMENT_DASHBOARD_SUB_BOARD = {
+    name: 'task-dashboard-board',
+    order: 2,
+    title: `${SUB}.board`,
+};
+//#endregion
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Task dashboard presets -----
+/** Task board list tile. */
+const AXP_TASK_BOARD_DIMENSIONS = defineDashboardWidgetDimensions({
+    sm: [[1, 6]],
+    md: [
+        [3, 4],
+        [4, 4],
+    ],
+    lg: [
+        [3, 4],
+        [4, 4],
+    ],
+    xl: [
+        [3, 4],
+        [4, 4],
+    ],
+    '2xl': [
+        [3, 4],
+        [4, 4],
+    ],
+    '3xl': [
+        [3, 4],
+        [4, 4],
+    ],
+    '4xl': [
+        [3, 4],
+        [4, 4],
+    ],
+});
+/** Filtered task-board shortcut launcher. */
+const AXP_TASK_BOARD_SHORTCUT_DIMENSIONS = defineDashboardWidgetDimensions({
+    sm: [[1, 2]],
+    md: [
+        [2, 2],
+        [3, 2],
+    ],
+    lg: [
+        [2, 2],
+        [3, 2],
+    ],
+    xl: [
+        [2, 2],
+        [3, 2],
+    ],
+    '2xl': [
+        [2, 2],
+        [3, 2],
+    ],
+    '3xl': [
+        [2, 2],
+        [3, 2],
+    ],
+    '4xl': [
+        [2, 2],
+        [3, 2],
+    ],
+});
+//#endregion
+
+const VALID_PRIORITIES = [
+    { title: 'Urgent', name: 'urgent' },
+    { title: 'High', name: 'high' },
+    { title: 'Normal', name: 'normal' },
+    { title: 'Low', name: 'low' },
+    { title: 'No Priority', name: 'no_priority' },
+];
+const VALID_DATE_RANGES = [
+    { title: 'Today', name: 'today' },
+    { title: 'This Week', name: 'this-week' },
+    { title: 'This Month', name: 'this-month' },
+];
+const AXPTaskBoardShortcut = {
+    name: RootConfig.widgets.taskBoardShortcut,
+    title: '@dashboard:widgets.task-board-shortcut.widget-title',
+    description: '@dashboard:widgets.task-board-shortcut.widget-description',
+    categories: [AXP_TASK_MANAGEMENT_DASHBOARD_WIDGET_CATEGORY],
+    subCategory: AXP_TASK_MANAGEMENT_DASHBOARD_SUB_SHORTCUT,
+    groups: [AXPWidgetGroupEnum.DashboardWidget],
+    type: 'dashboard',
+    icon: 'fa-light fa-clipboard-list-check',
+    properties: [
+        cloneProperty(AXP_DATA_PATH_PROPERTY, { visible: false }),
+        // ====== Task Type ======
+        {
+            order: 0,
+            name: 'taskTypes',
+            title: '@task-management:task-board.filter.task-type',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                dataType: 'object',
+                interface: {
+                    name: 'taskTypes',
+                    path: 'options.taskTypes',
+                    type: AXPWidgetsCatalog.select,
+                    options: {
+                        multiple: true,
+                        textField: 'title',
+                        valueField: 'name',
+                        dataSource: AXMTaskManagementQueryKeys.ListTaskTypes,
+                    },
+                },
+            },
+            visible: true,
+        },
+        // ====== Asigned To ======
+        {
+            order: 1,
+            name: 'assignee',
+            title: '@task-management:task-board.filter.assignee',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                dataType: 'object',
+                interface: {
+                    name: 'assignee',
+                    path: 'options.assignee',
+                    type: AXPWidgetsCatalog.select,
+                    options: {
+                        multiple: true,
+                        valueField: 'id',
+                        allowSearch: true,
+                        dataSource: AXMTaskManagementQueryKeys.TaskBoardAssignees,
+                        textField: 'displayName',
+                    },
+                },
+            },
+            visible: true,
+        },
+        // ====== Priority ======
+        {
+            order: 2,
+            name: 'priority',
+            title: '@task-management:task-board.filter.priority',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                dataType: 'object',
+                interface: {
+                    name: 'priority',
+                    path: 'options.priority',
+                    type: AXPWidgetsCatalog.select,
+                    options: {
+                        multiple: true,
+                        textField: 'title',
+                        valueField: 'name',
+                        dataSource: VALID_PRIORITIES,
+                    },
+                },
+            },
+            visible: true,
+        },
+        // ====== Date Range ======
+        {
+            order: 3,
+            name: 'dateRange',
+            title: '@task-management:task-board.filter.date-range',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                dataType: 'object',
+                defaultValue: { title: 'This Month', name: 'this-month' },
+                interface: {
+                    name: 'dateRange',
+                    path: 'options.dateRange',
+                    type: AXPWidgetsCatalog.select,
+                    options: {
+                        textField: 'title',
+                        valueField: 'name',
+                        dataSource: VALID_DATE_RANGES,
+                    },
+                },
+            },
+            visible: true,
+        },
+    ],
+    components: {
+        view: {
+            component: () => Promise.resolve().then(function () { return taskBoardShortcut_component; }).then((c) => c.AXPTaskBoardShortcutViewComponent),
+        },
+    },
+    meta: {
+        dimensions: AXP_TASK_BOARD_SHORTCUT_DIMENSIONS,
+    },
+};
+
+const NO_PRIORITY_KEY = 'no_priority';
+const PRIORITY_LABEL_KEYS = {
+    urgent: '@task-management:task-board.priority.urgent',
+    high: '@task-management:task-board.priority.high',
+    normal: '@task-management:task-board.priority.normal',
+    low: '@task-management:task-board.priority.low',
+    no_priority: '@task-management:task-board.priority.no-priority',
+};
+class AXPTaskBoardWidgetViewComponent extends AXPLayoutBaseWidgetComponent {
+    constructor() {
+        super();
+        this.taskClick = output();
+        this.taskBoardService = inject(AXPTaskBoardService);
+        this.taskPopoverOverlay = inject(AXMTaskBoardTaskPopoverOverlayService);
+        this.dueStatusProviderService = inject(AXPDueStatusProviderService);
+        this.settingsService = inject(AXPSettingsService);
+        this.formatService = inject(AXFormatService);
+        this.translationService = inject(AXTranslationService);
+        this.localeService = inject(AXLocaleService);
+        this.destroyRef = inject(DestroyRef);
+        this.maxItems = computed(() => this.options()?.['maxItems'] ?? 10, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "maxItems" }] : /* istanbul ignore next */ []));
+        this.assignee = computed(() => this.options()?.['assignee'] ?? [], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "assignee" }] : /* istanbul ignore next */ []));
+        this.selectedTaskTypes = computed(() => {
+            const raw = this.options()?.['taskTypes'] ?? this.options()?.['taskType'];
+            if (!raw) {
+                return [];
+            }
+            return Array.isArray(raw) ? raw : [raw];
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedTaskTypes" }] : /* istanbul ignore next */ []));
+        this.sortBy = computed(() => this.options()?.['sortBy'] ?? { title: 'Priority', name: 'priority' }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "sortBy" }] : /* istanbul ignore next */ []));
+        this.widgetColorBy = computed(() => this.options()?.['colorBy'], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "widgetColorBy" }] : /* istanbul ignore next */ []));
+        this.globalColorBy = signal('dueDate', /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "globalColorBy" }] : /* istanbul ignore next */ []));
+        this.allTasks = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "allTasks" }] : /* istanbul ignore next */ []));
+        this.selectedPriorities = signal(new Set([...AXPTASK_PRIORITIES, NO_PRIORITY_KEY]), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedPriorities" }] : /* istanbul ignore next */ []));
+        this.selectedDueStatuses = signal(new Set(getDefaultDueStatusDefinitions().map((item) => item.name)), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "selectedDueStatuses" }] : /* istanbul ignore next */ []));
+        this.effectiveColorBy = computed(() => this.widgetColorBy() ?? this.globalColorBy(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "effectiveColorBy" }] : /* istanbul ignore next */ []));
+        this.filteredTasks = computed(() => {
+            const tasks = this.allTasks();
+            const limit = this.maxItems();
+            const selectedTypes = this.selectedTaskTypes();
+            const selectedPrioritiesSet = this.selectedPriorities();
+            const selectedDueStatusSet = this.selectedDueStatuses();
+            const selectedTypeNames = new Set(selectedTypes.map((t) => t.name));
+            const typeFiltered = selectedTypes.length > 0
+                ? tasks.filter((task) => task.provider && selectedTypeNames.has(task.provider))
+                : tasks;
+            const priorityFiltered = typeFiltered.filter((task) => {
+                const priorityKey = getTaskPriorityFilterKey(task);
+                return selectedPrioritiesSet.has(priorityKey);
+            });
+            const dueStatusFiltered = priorityFiltered.filter((task) => matchesTaskDueStatusFilter(task, [...selectedDueStatusSet]));
+            const sorted = this.sortTasks([...dueStatusFiltered]);
+            return sorted.slice(0, limit);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "filteredTasks" }] : /* istanbul ignore next */ []));
+        this.priorityBadges = computed(() => {
+            const tasks = this.getTypeFilteredTasks();
+            const counts = [...AXPTASK_PRIORITIES, NO_PRIORITY_KEY].reduce((acc, key) => {
+                acc[key] = 0;
+                return acc;
+            }, {});
+            for (const task of tasks) {
+                counts[getTaskPriorityFilterKey(task)]++;
+            }
+            const priorityBadges = AXPTASK_PRIORITIES.map((priority) => ({
+                name: priority,
+                label: PRIORITY_LABEL_KEYS[priority],
+                count: counts[priority],
+                color: getTaskPriorityColor(priority),
+            }));
+            return [
+                ...priorityBadges,
+                {
+                    name: NO_PRIORITY_KEY,
+                    label: PRIORITY_LABEL_KEYS[NO_PRIORITY_KEY],
+                    count: counts[NO_PRIORITY_KEY],
+                    color: 'secondary',
+                },
+            ].filter((badge) => badge.count > 0);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "priorityBadges" }] : /* istanbul ignore next */ []));
+        this.dueStatusBadges = computed(() => {
+            const tasks = this.getTypeFilteredTasks();
+            const definitions = getDefaultDueStatusDefinitions();
+            const counts = definitions.reduce((acc, definition) => {
+                acc[definition.name] = 0;
+                return acc;
+            }, {});
+            for (const task of tasks) {
+                const key = get(task.data, 'dueStatusKey');
+                if (key && key in counts) {
+                    counts[key]++;
+                }
+            }
+            return definitions
+                .map((definition) => ({
+                name: definition.name,
+                label: definition.title,
+                count: counts[definition.name],
+                color: definition.color,
+            }))
+                .filter((badge) => badge.count > 0);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "dueStatusBadges" }] : /* istanbul ignore next */ []));
+        this.hasFilterToolbar = computed(() => this.priorityBadges().length > 0 || this.dueStatusBadges().length > 0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasFilterToolbar" }] : /* istanbul ignore next */ []));
+        this.hasNarrowedFilters = computed(() => {
+            const allPriorityCount = AXPTASK_PRIORITIES.length + 1;
+            const allDueStatusCount = getDefaultDueStatusDefinitions().length;
+            return (this.selectedPriorities().size < allPriorityCount ||
+                this.selectedDueStatuses().size < allDueStatusCount);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "hasNarrowedFilters" }] : /* istanbul ignore next */ []));
+        this.#loadTasks = effect(() => {
+            this.localeService.activeProfile().localeInfo?.code;
+            this.maxItems();
+            this.assignee();
+            this.selectedTaskTypes();
+            this.sortBy();
+            void this.reloadTasks();
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#loadTasks" }] : /* istanbul ignore next */ []));
+        void this.settingsService
+            .scope(AXPPlatformScope.User)
+            .get(AXMTaskBoardSettings.ColorBy)
+            .then((value) => {
+            if (value) {
+                this.globalColorBy.set(value);
+            }
+        });
+        this.taskBoardService.refresh$
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((data) => {
+            void this.handleBoardRefresh(data);
+        });
+        this.taskBoardService.close$
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((data) => {
+            const active = this.taskPopoverOverlay.getActiveTask();
+            if (!active?.provider) {
+                return;
+            }
+            if (data.provider && data.provider !== active.provider) {
+                return;
+            }
+            this.taskPopoverOverlay.close();
+        });
+    }
+    #loadTasks;
+    onPriorityFilterChange(priorityKey) {
+        this.selectedPriorities.update((currentSet) => {
+            const newSet = new Set(currentSet);
+            if (newSet.has(priorityKey)) {
+                newSet.delete(priorityKey);
+            }
+            else {
+                newSet.add(priorityKey);
+            }
+            return newSet;
+        });
+    }
+    onDueStatusFilterChange(dueStatusKey) {
+        this.selectedDueStatuses.update((currentSet) => {
+            const newSet = new Set(currentSet);
+            if (newSet.has(dueStatusKey)) {
+                newSet.delete(dueStatusKey);
+            }
+            else {
+                newSet.add(dueStatusKey);
+            }
+            return newSet;
+        });
+    }
+    isPriorityFilterActive(priorityKey) {
+        return this.selectedPriorities().has(priorityKey);
+    }
+    isDueStatusFilterActive(dueStatusKey) {
+        return this.selectedDueStatuses().has(dueStatusKey);
+    }
+    resetFilters() {
+        this.selectedPriorities.set(new Set([...AXPTASK_PRIORITIES, NO_PRIORITY_KEY]));
+        this.selectedDueStatuses.set(new Set(getDefaultDueStatusDefinitions().map((item) => item.name)));
+    }
+    async onTaskClick(task, event) {
+        const anchor = event.currentTarget;
+        if (anchor) {
+            await this.taskPopoverOverlay.open({
+                task,
+                anchor,
+                offsetX: 12,
+                offsetY: 12,
+                adaptivityEnabled: true,
+            });
+        }
+        this.taskClick.emit(task);
+    }
+    getStatusColor(task) {
+        return resolveTaskBoardStatusColor(task);
+    }
+    getAccentClass(task) {
+        const colorToken = resolveTaskBoardAccentColor(task, this.effectiveColorBy());
+        return buildTaskAccentSurfaceCssClass(colorToken);
+    }
+    hasExplicitDueDate(task) {
+        return get(task.data, 'hasExplicitDueDate') === true;
+    }
+    getProviderTitle(task) {
+        if (!task.provider) {
+            return null;
+        }
+        return (this.taskBoardService.getTaskTypeOption(task.provider)?.title ?? null);
+    }
+    getProviderIcon(task) {
+        if (!task.provider) {
+            return 'fa-light fa-layer-group';
+        }
+        return (this.taskBoardService.getTaskTypeOption(task.provider)?.icon ??
+            'fa-light fa-layer-group');
+    }
+    getTypeFilteredTasks() {
+        const tasks = this.allTasks();
+        const selectedTypes = this.selectedTaskTypes();
+        const selectedTypeNames = new Set(selectedTypes.map((t) => t.name));
+        return selectedTypes.length > 0
+            ? tasks.filter((task) => task.provider && selectedTypeNames.has(task.provider))
+            : tasks;
+    }
+    async handleBoardRefresh(data) {
+        const active = this.taskPopoverOverlay.getActiveTask();
+        if (data?.provider &&
+            active?.provider &&
+            data.provider !== active.provider) {
+            return;
+        }
+        this.taskBoardService.invalidateTaskCache();
+        await this.reloadTasks();
+        if (!active?.provider) {
+            return;
+        }
+        const updated = this.allTasks().find((task) => task.id === active.id);
+        if (updated) {
+            await this.taskPopoverOverlay.refreshTask({
+                ...updated,
+                provider: active.provider,
+            });
+            return;
+        }
+        this.taskPopoverOverlay.close();
+    }
+    reloadTasks() {
+        const limit = this.maxItems();
+        const assignee = this.assignee();
+        const selectedTypes = this.selectedTaskTypes();
+        const typeNames = selectedTypes.map((t) => t.name);
+        return this.taskBoardService
+            .getTasks({
+            take: limit,
+            assigneeIds: assignee.map((a) => a.id),
+            types: typeNames,
+        })
+            .then(async (tasks) => {
+            const labeled = await resolveTaskBoardSchedulerLabels(tasks.items, this.translationService, this.formatService, this.settingsService);
+            const enriched = labeled.map((task) => this.dueStatusProviderService.attachDueStatusToTask(task));
+            this.allTasks.set(enriched);
+        });
+    }
+    compareByPriority(a, b) {
+        const priorityA = getTaskPriorityFilterKey(a);
+        const priorityB = getTaskPriorityFilterKey(b);
+        return TASK_PRIORITY_ORDER[priorityA] - TASK_PRIORITY_ORDER[priorityB];
+    }
+    compareByDueDate(a, b) {
+        const now = Date.now();
+        const dateA = this.hasExplicitDueDate(a) && a.endDate
+            ? new Date(a.endDate).getTime()
+            : null;
+        const dateB = this.hasExplicitDueDate(b) && b.endDate
+            ? new Date(b.endDate).getTime()
+            : null;
+        if (dateA === null && dateB === null) {
+            return 0;
+        }
+        if (dateA === null) {
+            return 1;
+        }
+        if (dateB === null) {
+            return -1;
+        }
+        return dateA - dateB;
+    }
+    sortTasks(tasks) {
+        const sortBy = this.sortBy().name;
+        return tasks.sort((a, b) => {
+            if (sortBy === 'priority') {
+                const priorityCompare = this.compareByPriority(a, b);
+                if (priorityCompare !== 0) {
+                    return priorityCompare;
+                }
+                return this.compareByDueDate(a, b);
+            }
+            const dateCompare = this.compareByDueDate(a, b);
+            if (dateCompare !== 0) {
+                return dateCompare;
+            }
+            return this.compareByPriority(a, b);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardWidgetViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.8", type: AXPTaskBoardWidgetViewComponent, isStandalone: true, selector: "ng-component", outputs: { taskClick: "taskClick" }, usesInheritance: true, ngImport: i0, template: "<div class=\"size-full p-3 flex flex-col gap-3\">\n  @if (hasFilterToolbar()) {\n    <section class=\"__filters\">\n      @if (priorityBadges().length > 0) {\n        <div class=\"__filter-group\">\n          <span class=\"__filter-label\">\n            {{\n              '@task-management:task-board.filter.priority' | translate | async\n            }}\n          </span>\n          <div class=\"__filter-chips\">\n            @for (badge of priorityBadges(); track badge.name) {\n              <ax-chips\n                [color]=\"badge.color\"\n                class=\"filter-badge ax-sm\"\n                [class.--active]=\"isPriorityFilterActive(badge.name)\"\n                [text]=\"\n                  ((badge.label | translate | async) ?? '') +\n                  ' (' +\n                  badge.count +\n                  ')'\n                \"\n                (click)=\"onPriorityFilterChange(badge.name)\"\n                [look]=\"\n                  isPriorityFilterActive(badge.name) ? 'solid' : 'outline'\n                \"\n              ></ax-chips>\n            }\n          </div>\n        </div>\n      }\n\n      @if (dueStatusBadges().length > 0) {\n        <div class=\"__filter-group\">\n          <span class=\"__filter-label\">\n            {{\n              '@task-management:task-board.filter.due-status'\n                | translate\n                | async\n            }}\n          </span>\n          <div class=\"__filter-chips\">\n            @for (badge of dueStatusBadges(); track badge.name) {\n              <ax-chips\n                [color]=\"badge.color\"\n                class=\"filter-badge ax-sm\"\n                [class.--active]=\"isDueStatusFilterActive(badge.name)\"\n                [text]=\"\n                  ((badge.label | translate | async) ?? '') +\n                  ' (' +\n                  badge.count +\n                  ')'\n                \"\n                (click)=\"onDueStatusFilterChange(badge.name)\"\n                [look]=\"\n                  isDueStatusFilterActive(badge.name) ? 'solid' : 'outline'\n                \"\n              ></ax-chips>\n            }\n          </div>\n        </div>\n      }\n    </section>\n\n    @if (hasNarrowedFilters()) {\n      <button type=\"button\" class=\"__filter-reset\" (click)=\"resetFilters()\">\n        <i class=\"fa-light fa-arrow-rotate-left\" aria-hidden=\"true\"></i>\n        <span>{{ '@acorex:common.general.clear' | translate | async }}</span>\n      </button>\n    }\n  }\n\n  <div class=\"overflow-auto overflow-x-hidden grow min-h-0\">\n    <div class=\"__list\">\n      @for (task of filteredTasks(); track task.id) {\n        <div class=\"__item\" (click)=\"onTaskClick(task, $event)\">\n          <div\n            class=\"__accent\"\n            [ngClass]=\"getAccentClass(task)\"\n            aria-hidden=\"true\"\n          ></div>\n\n          <div class=\"__content\">\n            <div class=\"__header\">\n              <p class=\"__title\" [title]=\"task.title\">{{ task.title }}</p>\n\n              @if (task.status.title) {\n                <ax-chips\n                  class=\"__status-chip ax-sm\"\n                  [look]=\"'twotone'\"\n                  [color]=\"getStatusColor(task)\"\n                  [text]=\"(task.status.title | translate | async)!\"\n                ></ax-chips>\n              }\n            </div>\n\n            <div class=\"__meta\">\n              @if (getProviderTitle(task); as providerTitle) {\n                <span\n                  class=\"__meta-item\"\n                  [title]=\"\n                    '@task-management:task-board.grid-headers.type'\n                      | translate\n                      | async\n                  \"\n                >\n                  <i [class]=\"getProviderIcon(task)\" aria-hidden=\"true\"></i>\n                  <span>{{ providerTitle | translate | async }}</span>\n                </span>\n              }\n\n              @if (hasExplicitDueDate(task) && task.endDate) {\n                <span\n                  class=\"__meta-item\"\n                  [title]=\"\n                    '@task-management:task-board.grid-headers.due-date'\n                      | translate\n                      | async\n                  \"\n                >\n                  <i class=\"fa-light fa-calendar\" aria-hidden=\"true\"></i>\n                  <span>{{\n                    task.endDate\n                      | format: 'datetime' : { format: 'datetime' }\n                      | async\n                  }}</span>\n                </span>\n              } @else if (task.createdAt) {\n                <span\n                  class=\"__meta-item\"\n                  [title]=\"\n                    '@task-management:task-board.grid-headers.received'\n                      | translate\n                      | async\n                  \"\n                >\n                  <i class=\"fa-light fa-inbox\" aria-hidden=\"true\"></i>\n                  <span>{{\n                    task.createdAt\n                      | format: 'datetime' : { format: 'datetime' }\n                      | async\n                  }}</span>\n                </span>\n              }\n\n              @if (task.reporter.fullName) {\n                <span\n                  class=\"__meta-item\"\n                  [title]=\"\n                    '@task-management:task-board.grid-headers.reporter'\n                      | translate\n                      | async\n                  \"\n                >\n                  <i class=\"fa-light fa-user-pen\" aria-hidden=\"true\"></i>\n                  <span>{{ task.reporter.fullName }}</span>\n                </span>\n              } @else if (task.assignee; as assignee) {\n                @if (assignee.fullName) {\n                  <span\n                    class=\"__meta-item\"\n                    [title]=\"\n                      '@task-management:task-board.grid-headers.assignee'\n                        | translate\n                        | async\n                    \"\n                  >\n                    <i class=\"fa-light fa-user\" aria-hidden=\"true\"></i>\n                    <span>{{ assignee.fullName }}</span>\n                  </span>\n                }\n              }\n            </div>\n          </div>\n        </div>\n      } @empty {\n        <axp-state-message\n          icon=\"fa-light fa-clipboard-list-check\"\n          [title]=\"'@dashboard:task-board.no-tasks-found.title'\"\n          [description]=\"'@dashboard:task-board.no-tasks-found.description'\"\n        ></axp-state-message>\n      }\n    </div>\n  </div>\n</div>\n", styles: ["@layer properties;:host{display:block;width:100%;height:100%}:host .__accent.axm-task-board-accent--primary{background-color:rgba(var(--ax-sys-color-primary-surface))}:host .__accent.axm-task-board-accent--secondary{background-color:rgba(var(--ax-sys-color-secondary-surface))}:host .__accent.axm-task-board-accent--success{background-color:rgba(var(--ax-sys-color-success-surface))}:host .__accent.axm-task-board-accent--warning{background-color:rgba(var(--ax-sys-color-warning-surface))}:host .__accent.axm-task-board-accent--danger{background-color:rgba(var(--ax-sys-color-danger-surface))}:host .__accent.axm-task-board-accent--accent1{background-color:rgba(var(--ax-sys-color-accent1-surface))}:host .__accent.axm-task-board-accent--accent2{background-color:rgba(var(--ax-sys-color-accent2-surface))}:host .__accent.axm-task-board-accent--accent3{background-color:rgba(var(--ax-sys-color-accent3-surface))}:host .__accent.axm-task-board-accent--neutral{background-color:var(--color-secondary-lightest);color:var(--color-on-secondary-lightest);border-color:var(--color-border-secondary-lightest)}:host .__accent.axm-task-board-accent--ghost{background-color:var(--color-secondary-lighter);color:var(--color-on-secondary-lighter);border-color:var(--color-border-secondary-lighter)}:host .__filters{display:flex;flex-shrink:0;gap:calc(var(--spacing, .25rem) * 2.5);border-radius:var(--radius-lg, .5rem);border-style:var(--tw-border-style);border-width:1px;background-color:var(--color-lightest);color:var(--color-on-lightest);border-color:var(--color-border-lightest);border-color:rgba(var(--ax-sys-color-lightest-surface));padding:calc(var(--spacing, .25rem) * 2.5)}:host .__filter-group{display:flex;min-width:0px;flex-direction:column;gap:calc(var(--spacing, .25rem) * 1.5)}:host .__filter-label{font-size:.6875rem;--tw-leading: 1;line-height:1;--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600);--tw-tracking: var(--tracking-wide, .025em);letter-spacing:var(--tracking-wide, .025em);text-transform:uppercase;opacity:60%}:host .__filter-chips{display:flex;flex-wrap:wrap;gap:calc(var(--spacing, .25rem) * 1.5)}:host .__filter-reset{display:inline-flex;align-items:center;gap:calc(var(--spacing, .25rem) * 1.5);align-self:flex-start;border-radius:var(--radius-md, .375rem);padding-inline:var(--spacing, .25rem);padding-block:calc(var(--spacing, .25rem) * .5);font-size:var(--text-xs, .75rem);line-height:var(--tw-leading, var(--text-xs--line-height, calc(1 / .75)));--tw-font-weight: var(--font-weight-medium, 500);font-weight:var(--font-weight-medium, 500);opacity:70%;transition-property:opacity;transition-timing-function:var(--tw-ease, var(--default-transition-timing-function, cubic-bezier(.4, 0, .2, 1)));transition-duration:var(--tw-duration, var(--default-transition-duration, .15s))}:host .__filter-reset:hover{text-decoration-line:underline;opacity:100%;text-underline-offset:2px}:host .__filter-reset i{font-size:.625rem}:host .__list{display:flex;flex-direction:column;gap:calc(var(--spacing, .25rem) * 2)}:host .__list>.__item{animation:slideIn .25s ease forwards;opacity:0%}:host .__list>.__item:nth-child(1){animation-delay:.04s}:host .__list>.__item:nth-child(2){animation-delay:.08s}:host .__list>.__item:nth-child(3){animation-delay:.12s}:host .__list>.__item:nth-child(4){animation-delay:.16s}:host .__list>.__item:nth-child(5){animation-delay:.2s}:host .__list>.__item:nth-child(6){animation-delay:.24s}:host .__list>.__item:nth-child(7){animation-delay:.28s}:host .__list>.__item:nth-child(8){animation-delay:.32s}:host .__list>.__item:nth-child(9){animation-delay:.36s}:host .__list>.__item:nth-child(10){animation-delay:.4s}:host .__item{display:flex;cursor:pointer;align-items:stretch;overflow:hidden;border-radius:var(--radius-lg, .5rem);border-style:var(--tw-border-style);border-width:1px;background-color:var(--color-lightest);color:var(--color-on-lightest);border-color:var(--color-border-lightest);border-color:rgba(var(--ax-sys-color-lightest-surface));text-align:start;transition:background-color .15s ease,border-color .15s ease,box-shadow .15s ease}:host .__item:hover{background-color:var(--color-lighter);color:var(--color-on-lighter);border-color:var(--color-border-lighter);border-color:rgba(var(--ax-sys-color-surface));box-shadow:0 1px 4px rgba(var(--ax-sys-color-on-surface),.06)}:host .__item:active{background-color:var(--color-light);color:var(--color-on-light);border-color:var(--color-border-light)}:host .__item .__accent{width:3px;flex-shrink:0;background-color:rgba(var(--ax-sys-color-lighter-surface))}:host .__item .__content{min-width:0px;flex:1;padding-inline:calc(var(--spacing, .25rem) * 3);padding-block:calc(var(--spacing, .25rem) * 2.5)}:host .__item .__header{display:flex;align-items:flex-start;justify-content:space-between;gap:calc(var(--spacing, .25rem) * 2)}:host .__item .__title{margin:0;min-width:0px;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));--tw-leading: var(--leading-snug, 1.375);line-height:var(--leading-snug, 1.375);--tw-font-weight: var(--font-weight-medium, 500);font-weight:var(--font-weight-medium, 500)}:host .__item .__status-chip{max-width:45%;flex-shrink:0;pointer-events:none}:host .__item .__meta{margin-top:calc(var(--spacing, .25rem) * 1.5);display:flex;flex-wrap:wrap;align-items:center;column-gap:calc(var(--spacing, .25rem) * 3);row-gap:calc(var(--spacing, .25rem) * 1.5);font-size:var(--text-xs, .75rem);line-height:var(--tw-leading, var(--text-xs--line-height, calc(1 / .75)));--tw-leading: var(--leading-tight, 1.25);line-height:var(--leading-tight, 1.25);opacity:80%}:host .__item .__meta-item{display:inline-flex;max-width:100%;min-width:0px;align-items:center;gap:var(--spacing, .25rem)}:host .__item .__meta-item i{flex-shrink:0;font-size:var(--text-xs, .75rem);line-height:var(--tw-leading, var(--text-xs--line-height, calc(1 / .75)));opacity:.85}:host .__item .__meta-item span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}:host .filter-badge{cursor:pointer;transition:transform .15s ease,opacity .15s ease,box-shadow .15s ease}:host .filter-badge:not(.--active){opacity:.78}:host .filter-badge:hover{transform:translateY(-1px);opacity:1}:host .filter-badge.--active{box-shadow:0 1px 2px rgba(var(--ax-sys-color-on-surface),.08)}@keyframes slideIn{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@property --tw-leading{syntax: \"*\"; inherits: false;}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@property --tw-tracking{syntax: \"*\"; inherits: false;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-border-style: solid;--tw-leading: initial;--tw-font-weight: initial;--tw-tracking: initial}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "component", type: AXChipsComponent, selector: "ax-chips", inputs: ["tabIndex", "color", "look", "text"], outputs: ["textChange"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "component", type: AXPStateMessageComponent, selector: "axp-state-message", inputs: ["mode", "icon", "title", "description", "titleParams", "descriptionParams", "look"] }, { kind: "pipe", type: i1$1.AsyncPipe, name: "async" }, { kind: "pipe", type: AXFormatPipe, name: "format" }, { kind: "pipe", type: i5.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXPTaskBoardWidgetViewComponent, decorators: [{
+            type: Component,
+            args: [{ imports: [
+                        CommonModule,
+                        AXFormatPipe,
+                        AXChipsComponent,
+                        AXTranslationModule,
+                        AXPStateMessageComponent,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"size-full p-3 flex flex-col gap-3\">\n  @if (hasFilterToolbar()) {\n    <section class=\"__filters\">\n      @if (priorityBadges().length > 0) {\n        <div class=\"__filter-group\">\n          <span class=\"__filter-label\">\n            {{\n              '@task-management:task-board.filter.priority' | translate | async\n            }}\n          </span>\n          <div class=\"__filter-chips\">\n            @for (badge of priorityBadges(); track badge.name) {\n              <ax-chips\n                [color]=\"badge.color\"\n                class=\"filter-badge ax-sm\"\n                [class.--active]=\"isPriorityFilterActive(badge.name)\"\n                [text]=\"\n                  ((badge.label | translate | async) ?? '') +\n                  ' (' +\n                  badge.count +\n                  ')'\n                \"\n                (click)=\"onPriorityFilterChange(badge.name)\"\n                [look]=\"\n                  isPriorityFilterActive(badge.name) ? 'solid' : 'outline'\n                \"\n              ></ax-chips>\n            }\n          </div>\n        </div>\n      }\n\n      @if (dueStatusBadges().length > 0) {\n        <div class=\"__filter-group\">\n          <span class=\"__filter-label\">\n            {{\n              '@task-management:task-board.filter.due-status'\n                | translate\n                | async\n            }}\n          </span>\n          <div class=\"__filter-chips\">\n            @for (badge of dueStatusBadges(); track badge.name) {\n              <ax-chips\n                [color]=\"badge.color\"\n                class=\"filter-badge ax-sm\"\n                [class.--active]=\"isDueStatusFilterActive(badge.name)\"\n                [text]=\"\n                  ((badge.label | translate | async) ?? '') +\n                  ' (' +\n                  badge.count +\n                  ')'\n                \"\n                (click)=\"onDueStatusFilterChange(badge.name)\"\n                [look]=\"\n                  isDueStatusFilterActive(badge.name) ? 'solid' : 'outline'\n                \"\n              ></ax-chips>\n            }\n          </div>\n        </div>\n      }\n    </section>\n\n    @if (hasNarrowedFilters()) {\n      <button type=\"button\" class=\"__filter-reset\" (click)=\"resetFilters()\">\n        <i class=\"fa-light fa-arrow-rotate-left\" aria-hidden=\"true\"></i>\n        <span>{{ '@acorex:common.general.clear' | translate | async }}</span>\n      </button>\n    }\n  }\n\n  <div class=\"overflow-auto overflow-x-hidden grow min-h-0\">\n    <div class=\"__list\">\n      @for (task of filteredTasks(); track task.id) {\n        <div class=\"__item\" (click)=\"onTaskClick(task, $event)\">\n          <div\n            class=\"__accent\"\n            [ngClass]=\"getAccentClass(task)\"\n            aria-hidden=\"true\"\n          ></div>\n\n          <div class=\"__content\">\n            <div class=\"__header\">\n              <p class=\"__title\" [title]=\"task.title\">{{ task.title }}</p>\n\n              @if (task.status.title) {\n                <ax-chips\n                  class=\"__status-chip ax-sm\"\n                  [look]=\"'twotone'\"\n                  [color]=\"getStatusColor(task)\"\n                  [text]=\"(task.status.title | translate | async)!\"\n                ></ax-chips>\n              }\n            </div>\n\n            <div class=\"__meta\">\n              @if (getProviderTitle(task); as providerTitle) {\n                <span\n                  class=\"__meta-item\"\n                  [title]=\"\n                    '@task-management:task-board.grid-headers.type'\n                      | translate\n                      | async\n                  \"\n                >\n                  <i [class]=\"getProviderIcon(task)\" aria-hidden=\"true\"></i>\n                  <span>{{ providerTitle | translate | async }}</span>\n                </span>\n              }\n\n              @if (hasExplicitDueDate(task) && task.endDate) {\n                <span\n                  class=\"__meta-item\"\n                  [title]=\"\n                    '@task-management:task-board.grid-headers.due-date'\n                      | translate\n                      | async\n                  \"\n                >\n                  <i class=\"fa-light fa-calendar\" aria-hidden=\"true\"></i>\n                  <span>{{\n                    task.endDate\n                      | format: 'datetime' : { format: 'datetime' }\n                      | async\n                  }}</span>\n                </span>\n              } @else if (task.createdAt) {\n                <span\n                  class=\"__meta-item\"\n                  [title]=\"\n                    '@task-management:task-board.grid-headers.received'\n                      | translate\n                      | async\n                  \"\n                >\n                  <i class=\"fa-light fa-inbox\" aria-hidden=\"true\"></i>\n                  <span>{{\n                    task.createdAt\n                      | format: 'datetime' : { format: 'datetime' }\n                      | async\n                  }}</span>\n                </span>\n              }\n\n              @if (task.reporter.fullName) {\n                <span\n                  class=\"__meta-item\"\n                  [title]=\"\n                    '@task-management:task-board.grid-headers.reporter'\n                      | translate\n                      | async\n                  \"\n                >\n                  <i class=\"fa-light fa-user-pen\" aria-hidden=\"true\"></i>\n                  <span>{{ task.reporter.fullName }}</span>\n                </span>\n              } @else if (task.assignee; as assignee) {\n                @if (assignee.fullName) {\n                  <span\n                    class=\"__meta-item\"\n                    [title]=\"\n                      '@task-management:task-board.grid-headers.assignee'\n                        | translate\n                        | async\n                    \"\n                  >\n                    <i class=\"fa-light fa-user\" aria-hidden=\"true\"></i>\n                    <span>{{ assignee.fullName }}</span>\n                  </span>\n                }\n              }\n            </div>\n          </div>\n        </div>\n      } @empty {\n        <axp-state-message\n          icon=\"fa-light fa-clipboard-list-check\"\n          [title]=\"'@dashboard:task-board.no-tasks-found.title'\"\n          [description]=\"'@dashboard:task-board.no-tasks-found.description'\"\n        ></axp-state-message>\n      }\n    </div>\n  </div>\n</div>\n", styles: ["@layer properties;:host{display:block;width:100%;height:100%}:host .__accent.axm-task-board-accent--primary{background-color:rgba(var(--ax-sys-color-primary-surface))}:host .__accent.axm-task-board-accent--secondary{background-color:rgba(var(--ax-sys-color-secondary-surface))}:host .__accent.axm-task-board-accent--success{background-color:rgba(var(--ax-sys-color-success-surface))}:host .__accent.axm-task-board-accent--warning{background-color:rgba(var(--ax-sys-color-warning-surface))}:host .__accent.axm-task-board-accent--danger{background-color:rgba(var(--ax-sys-color-danger-surface))}:host .__accent.axm-task-board-accent--accent1{background-color:rgba(var(--ax-sys-color-accent1-surface))}:host .__accent.axm-task-board-accent--accent2{background-color:rgba(var(--ax-sys-color-accent2-surface))}:host .__accent.axm-task-board-accent--accent3{background-color:rgba(var(--ax-sys-color-accent3-surface))}:host .__accent.axm-task-board-accent--neutral{background-color:var(--color-secondary-lightest);color:var(--color-on-secondary-lightest);border-color:var(--color-border-secondary-lightest)}:host .__accent.axm-task-board-accent--ghost{background-color:var(--color-secondary-lighter);color:var(--color-on-secondary-lighter);border-color:var(--color-border-secondary-lighter)}:host .__filters{display:flex;flex-shrink:0;gap:calc(var(--spacing, .25rem) * 2.5);border-radius:var(--radius-lg, .5rem);border-style:var(--tw-border-style);border-width:1px;background-color:var(--color-lightest);color:var(--color-on-lightest);border-color:var(--color-border-lightest);border-color:rgba(var(--ax-sys-color-lightest-surface));padding:calc(var(--spacing, .25rem) * 2.5)}:host .__filter-group{display:flex;min-width:0px;flex-direction:column;gap:calc(var(--spacing, .25rem) * 1.5)}:host .__filter-label{font-size:.6875rem;--tw-leading: 1;line-height:1;--tw-font-weight: var(--font-weight-semibold, 600);font-weight:var(--font-weight-semibold, 600);--tw-tracking: var(--tracking-wide, .025em);letter-spacing:var(--tracking-wide, .025em);text-transform:uppercase;opacity:60%}:host .__filter-chips{display:flex;flex-wrap:wrap;gap:calc(var(--spacing, .25rem) * 1.5)}:host .__filter-reset{display:inline-flex;align-items:center;gap:calc(var(--spacing, .25rem) * 1.5);align-self:flex-start;border-radius:var(--radius-md, .375rem);padding-inline:var(--spacing, .25rem);padding-block:calc(var(--spacing, .25rem) * .5);font-size:var(--text-xs, .75rem);line-height:var(--tw-leading, var(--text-xs--line-height, calc(1 / .75)));--tw-font-weight: var(--font-weight-medium, 500);font-weight:var(--font-weight-medium, 500);opacity:70%;transition-property:opacity;transition-timing-function:var(--tw-ease, var(--default-transition-timing-function, cubic-bezier(.4, 0, .2, 1)));transition-duration:var(--tw-duration, var(--default-transition-duration, .15s))}:host .__filter-reset:hover{text-decoration-line:underline;opacity:100%;text-underline-offset:2px}:host .__filter-reset i{font-size:.625rem}:host .__list{display:flex;flex-direction:column;gap:calc(var(--spacing, .25rem) * 2)}:host .__list>.__item{animation:slideIn .25s ease forwards;opacity:0%}:host .__list>.__item:nth-child(1){animation-delay:.04s}:host .__list>.__item:nth-child(2){animation-delay:.08s}:host .__list>.__item:nth-child(3){animation-delay:.12s}:host .__list>.__item:nth-child(4){animation-delay:.16s}:host .__list>.__item:nth-child(5){animation-delay:.2s}:host .__list>.__item:nth-child(6){animation-delay:.24s}:host .__list>.__item:nth-child(7){animation-delay:.28s}:host .__list>.__item:nth-child(8){animation-delay:.32s}:host .__list>.__item:nth-child(9){animation-delay:.36s}:host .__list>.__item:nth-child(10){animation-delay:.4s}:host .__item{display:flex;cursor:pointer;align-items:stretch;overflow:hidden;border-radius:var(--radius-lg, .5rem);border-style:var(--tw-border-style);border-width:1px;background-color:var(--color-lightest);color:var(--color-on-lightest);border-color:var(--color-border-lightest);border-color:rgba(var(--ax-sys-color-lightest-surface));text-align:start;transition:background-color .15s ease,border-color .15s ease,box-shadow .15s ease}:host .__item:hover{background-color:var(--color-lighter);color:var(--color-on-lighter);border-color:var(--color-border-lighter);border-color:rgba(var(--ax-sys-color-surface));box-shadow:0 1px 4px rgba(var(--ax-sys-color-on-surface),.06)}:host .__item:active{background-color:var(--color-light);color:var(--color-on-light);border-color:var(--color-border-light)}:host .__item .__accent{width:3px;flex-shrink:0;background-color:rgba(var(--ax-sys-color-lighter-surface))}:host .__item .__content{min-width:0px;flex:1;padding-inline:calc(var(--spacing, .25rem) * 3);padding-block:calc(var(--spacing, .25rem) * 2.5)}:host .__item .__header{display:flex;align-items:flex-start;justify-content:space-between;gap:calc(var(--spacing, .25rem) * 2)}:host .__item .__title{margin:0;min-width:0px;flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:var(--text-sm, .875rem);line-height:var(--tw-leading, var(--text-sm--line-height, calc(1.25 / .875)));--tw-leading: var(--leading-snug, 1.375);line-height:var(--leading-snug, 1.375);--tw-font-weight: var(--font-weight-medium, 500);font-weight:var(--font-weight-medium, 500)}:host .__item .__status-chip{max-width:45%;flex-shrink:0;pointer-events:none}:host .__item .__meta{margin-top:calc(var(--spacing, .25rem) * 1.5);display:flex;flex-wrap:wrap;align-items:center;column-gap:calc(var(--spacing, .25rem) * 3);row-gap:calc(var(--spacing, .25rem) * 1.5);font-size:var(--text-xs, .75rem);line-height:var(--tw-leading, var(--text-xs--line-height, calc(1 / .75)));--tw-leading: var(--leading-tight, 1.25);line-height:var(--leading-tight, 1.25);opacity:80%}:host .__item .__meta-item{display:inline-flex;max-width:100%;min-width:0px;align-items:center;gap:var(--spacing, .25rem)}:host .__item .__meta-item i{flex-shrink:0;font-size:var(--text-xs, .75rem);line-height:var(--tw-leading, var(--text-xs--line-height, calc(1 / .75)));opacity:.85}:host .__item .__meta-item span{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}:host .filter-badge{cursor:pointer;transition:transform .15s ease,opacity .15s ease,box-shadow .15s ease}:host .filter-badge:not(.--active){opacity:.78}:host .filter-badge:hover{transform:translateY(-1px);opacity:1}:host .filter-badge.--active{box-shadow:0 1px 2px rgba(var(--ax-sys-color-on-surface),.08)}@keyframes slideIn{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}@property --tw-border-style{syntax: \"*\"; inherits: false; initial-value: solid;}@property --tw-leading{syntax: \"*\"; inherits: false;}@property --tw-font-weight{syntax: \"*\"; inherits: false;}@property --tw-tracking{syntax: \"*\"; inherits: false;}@layer properties{@supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-border-style: solid;--tw-leading: initial;--tw-font-weight: initial;--tw-tracking: initial}}}\n/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */\n"] }]
+        }], ctorParameters: () => [], propDecorators: { taskClick: [{ type: i0.Output, args: ["taskClick"] }] } });
+
+var taskBoardWidget_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPTaskBoardWidgetViewComponent: AXPTaskBoardWidgetViewComponent
+});
+
+const AXPTaskBoardWidget = {
+    name: RootConfig.widgets.taskBoard,
+    title: '@dashboard:widgets.task-board-widget.widget-title',
+    description: '@dashboard:widgets.task-board-widget.widget-description',
+    categories: [AXP_TASK_MANAGEMENT_DASHBOARD_WIDGET_CATEGORY],
+    subCategory: AXP_TASK_MANAGEMENT_DASHBOARD_SUB_BOARD,
+    groups: [AXPWidgetGroupEnum.DashboardWidget],
+    type: 'dashboard',
+    icon: 'fa-light fa-clipboard-list-check',
+    properties: [
+        cloneProperty(AXP_DATA_PATH_PROPERTY, { visible: false }),
+        // ====== Title ======
+        {
+            order: 1,
+            name: 'title',
+            title: '@dashboard:task-board.task-board-title',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                dataType: 'string',
+                defaultValue: 'Task Board',
+                interface: {
+                    name: 'title',
+                    path: 'options.title',
+                    type: AXPWidgetsCatalog.text,
+                    options: {
+                        placeholder: '@dashboard:widgets.task-board-widget.title-placeholder',
+                    },
+                    triggers: [
+                        {
+                            event: `{{ events.context('options.taskTypes') }}`,
+                            action: `{{ widget.setValue(widget.find("taskTypes").output('item').title==='All' ? 'Task Board' : widget.find("taskTypes").output('item').title) }}`,
+                        },
+                    ],
+                },
+            },
+            visible: true,
+        },
+        // ====== Task Type ======
+        {
+            order: 0,
+            name: 'taskTypes',
+            title: '@task-management:task-board.filter.task-type',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                dataType: 'object',
+                interface: {
+                    name: 'taskTypes',
+                    path: 'options.taskTypes',
+                    type: AXPWidgetsCatalog.select,
+                    options: {
+                        multiple: true,
+                        textField: 'title',
+                        valueField: 'name',
+                        dataSource: AXMTaskManagementQueryKeys.ListTaskTypes,
+                    },
+                },
+            },
+            visible: true,
+        },
+        // ====== Sort By ======
+        {
+            name: 'sortBy',
+            title: '@dashboard:task-board.sort-by',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                dataType: 'object',
+                defaultValue: { title: 'Priority', name: 'priority' },
+                interface: {
+                    name: 'sortBy',
+                    path: 'options.sortBy',
+                    type: AXPWidgetsCatalog.select,
+                    options: {
+                        valueField: 'name',
+                        textField: 'title',
+                        dataSource: [
+                            { title: 'Priority', name: 'priority' },
+                            { title: 'Due Date', name: 'dueDate' },
+                        ],
+                        multiple: false,
+                        direction: 'horizontal',
+                    },
+                },
+            },
+            visible: true,
+        },
+        // ====== Color By ======
+        {
+            name: 'colorBy',
+            title: '@dashboard:task-board.color-by',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                dataType: 'string',
+                interface: {
+                    name: 'colorBy',
+                    path: 'options.colorBy',
+                    type: AXPWidgetsCatalog.select,
+                    options: {
+                        valueField: 'name',
+                        textField: 'title',
+                        allowClear: true,
+                        dataSource: [
+                            { title: 'Due Date', name: 'dueDate' },
+                            { title: 'Priority', name: 'priority' },
+                            { title: 'Status', name: 'status' },
+                        ],
+                    },
+                },
+            },
+            visible: true,
+        },
+        // ====== Display options ======
+        {
+            name: 'maxItems',
+            title: '@dashboard:task-board.max-items',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                defaultValue: 10,
+                dataType: 'number',
+                interface: {
+                    name: 'maxItems',
+                    path: 'options.maxItems',
+                    type: AXPWidgetsCatalog.number,
+                    options: {
+                        minValue: 1,
+                        maxValue: 50,
+                    },
+                },
+            },
+            visible: true,
+        },
+        // ====== Asigned To ======
+        {
+            name: 'assignee',
+            title: '@dashboard:task-board.asigned-to',
+            group: AXP_APPEARANCE_PROPERTY_GROUP,
+            schema: {
+                dataType: 'object',
+                interface: {
+                    name: 'assignee',
+                    path: 'options.assignee',
+                    type: AXPWidgetsCatalog.select,
+                    options: {
+                        multiple: true,
+                        valueField: 'id',
+                        allowSearch: true,
+                        dataSource: AXMTaskManagementQueryKeys.TaskBoardAssignees,
+                        textField: 'displayName',
+                    },
+                },
+            },
+            visible: true,
+        },
+    ],
+    components: {
+        view: {
+            component: () => Promise.resolve().then(function () { return taskBoardWidget_component; }).then((c) => c.AXPTaskBoardWidgetViewComponent),
+        },
+    },
+    meta: {
+        dimensions: AXP_TASK_BOARD_DIMENSIONS,
+    },
+};
+
+//#endregion
+//#region ----   Task Management Widgets Provider   ----
+const TASK_WIDGETS = [AXPTaskBoardWidget, AXPTaskBoardShortcut];
+class AXMTaskManagementWidgetsProvider {
+    getWidgets() {
+        return TASK_WIDGETS;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskManagementWidgetsProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskManagementWidgetsProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskManagementWidgetsProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#endregion
+//#region ---- Permission Definition Provider ----
+/**
+ * Registers task capabilities into the shared Projects & Work group.
+ */
+class AXMPermissionDefinitionProvider {
+    async define(context) {
+        const keys = AXPProjectsWorkPermissionKeys;
+        const groups = AXPCommonPermissionGroupKeys;
+        const P = '@common:projects-work.permissions';
+        const G = '@common:permission-groups';
+        context.addGroup(groups.ProjectsWork.Root, `${G}.projects-work.title`, `${G}.projects-work.description`, { order: 60 });
+        context
+            .addGroup(groups.ProjectsWork.Tasks, `${G}.projects-work-tasks.title`, `${G}.projects-work-tasks.description`, { parent: groups.ProjectsWork.Root, order: 20 })
+            .addPermission(keys.MaintainTasks, `${P}.maintain-tasks.title`, `${P}.maintain-tasks.description`)
+            .endPermission()
+            .addPermission(keys.ViewAllTasks, `${P}.view-all-tasks.title`, `${P}.view-all-tasks.description`)
+            .endPermission()
+            .endGroup();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMPermissionDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Constants -----
+/** Menu `badgeKey` for Task Board. */
+const AXM_TASK_BOARD_BADGE_KEY = 'task-management-task-board-badge';
+const TASK_MANAGEMENT_COMMAND_PREFIX = `${RootConfig.module.name}.`;
+const WORKFLOW_MANAGEMENT_COMMAND_PREFIX = 'WorkflowManagement.';
+//#endregion
+//#region ----- Task badge provider -----
+/**
+ * Shows the current user's assigned task count on the Task Board menu item.
+ *
+ * On user switch: clears the badge immediately, invalidates task cache, and refetches.
+ * In-flight counts from a previous user are ignored.
+ *
+ * Refreshes after:
+ * - task-management / workflow-management commands
+ * - entity CRUD for Task (`Entity:Insert:Default` etc.)
+ * - realtime `entity.mutation` → layout refresh broadcast for Task, TaskAssignment, WorkflowInstance
+ */
+class AXMTaskBoardBadgeProvider extends AXPTaskBadgeProvider {
+    //#endregion
+    constructor() {
+        super();
+        //#region ----- Services & Dependencies -----
+        this.taskBoardService = inject(AXPTaskBoardService);
+        this.sessionService = inject(AXPSessionService);
+        this.commandEvents = inject(AXPCommandEventsService);
+        this.entityBroadcast = inject(AXPEntityBroadcastService);
+        this.eventService = inject(AXPBroadcastEventService);
+        this.destroyRef = inject(DestroyRef);
+        //#endregion
+        //#region ----- Signals & Properties -----
+        this.key = AXM_TASK_BOARD_BADGE_KEY;
+        this.count = signal(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "count" }] : /* istanbul ignore next */ []));
+        /** Bumped on every refresh so stale async results cannot overwrite a newer user/session. */
+        this.refreshGeneration = 0;
+        // User switch / login: update immediately (no debounce).
+        this.sessionService.user$
+            .pipe(distinctUntilChanged((prev, next) => prev?.id === next?.id), takeUntilDestroyed(this.destroyRef))
+            .subscribe((user) => {
+            // Clear stale badge from previous user right away.
+            this.count.set(0);
+            if (user?.id != null) {
+                void this.refresh({ resetProviders: true });
+            }
+        });
+        // After auth completes (login / user switch), refetch even if user id was already streamed.
+        this.sessionService.status$
+            .pipe(filter((status) => status === AXPSessionStatus.Authenticated), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            // Touch getter so storage-synced user switches emit on user$ when needed.
+            const userId = this.sessionService.user?.id;
+            if (userId != null) {
+                void this.refresh({ resetProviders: true });
+            }
+            else {
+                this.count.set(0);
+            }
+        });
+        const unsubscribeCommands = this.commandEvents.listen((event) => {
+            if (this.isRelevantCommandEvent(event)) {
+                void this.handleCommandEvent(event);
+            }
+        });
+        this.eventService
+            .listen('task-board.refresh')
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            void this.refresh();
+        });
+        this.taskBoardService.refresh$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
+            void this.refresh();
+        });
+        const layoutSub = this.entityBroadcast.listenLayoutRefresh().subscribe(({ data }) => {
+            if (isTaskBoardRealtimeEntity(data?.name)) {
+                void this.refresh();
+            }
+        });
+        this.destroyRef.onDestroy(() => {
+            unsubscribeCommands();
+            layoutSub.unsubscribe();
+        });
+    }
+    //#region ----- Badge actions -----
+    async refresh(options) {
+        const generation = ++this.refreshGeneration;
+        const currentUserId = this.sessionService.user?.id;
+        if (currentUserId == null) {
+            if (generation === this.refreshGeneration) {
+                this.count.set(0);
+            }
+            return;
+        }
+        this.taskBoardService.invalidateTaskCache();
+        try {
+            if (options?.resetProviders) {
+                await this.taskBoardService.resolveProviders({ force: true });
+            }
+            // Do not pass a small `take`: multi-provider merge uses client-side length as total.
+            const result = await this.taskBoardService.getTasks({
+                assigneeIds: [currentUserId],
+            });
+            if (generation !== this.refreshGeneration) {
+                return;
+            }
+            if (this.sessionService.user?.id !== currentUserId) {
+                return;
+            }
+            this.count.set(result.total ?? 0);
+        }
+        catch {
+            if (generation === this.refreshGeneration) {
+                this.count.set(0);
+            }
+        }
+    }
+    isRelevantCommandEvent(event) {
+        if (event.key.startsWith(TASK_MANAGEMENT_COMMAND_PREFIX) ||
+            event.key.startsWith(WORKFLOW_MANAGEMENT_COMMAND_PREFIX)) {
+            return true;
+        }
+        const input = event.input;
+        const entity = get(input, 'entity');
+        if (entity === TASK_BOARD_TASK_ENTITY) {
+            return true;
+        }
+        const entityInfo = get(input, 'entityInfo');
+        return (get(entityInfo, 'source') === TASK_BOARD_TASK_ENTITY ||
+            (get(entityInfo, 'module') === RootConfig.module.name &&
+                get(entityInfo, 'name') === RootConfig.entities.task.name));
+    }
+    async handleCommandEvent(event) {
+        if (!event || event.stage !== 'after' || !event.success) {
+            return;
+        }
+        await this.refresh();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskBoardBadgeProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskBoardBadgeProvider, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskBoardBadgeProvider, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class AXMTaskManagementMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+        this.sessionService = inject(AXPSessionService);
+        this.settingsService = inject(AXPSettingsService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        const keys = AXPProjectsWorkPermissionKeys;
+        const applicationName = this.sessionService.application?.name ?? '';
+        const taskBoardPath = await this.resolveTaskBoardMenuPath(applicationName, module.name);
+        context.addItems([
+            {
+                name: AXPTaskManagementMenuKeys.TaskBoard,
+                priority: 0,
+                text: '@task-management:task-board.page-title',
+                type: 'menu',
+                icon: 'fa-light fa-list-check',
+                path: taskBoardPath,
+                badgeKey: AXM_TASK_BOARD_BADGE_KEY,
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.MaintainTasks],
+                },
+            },
+            // {
+            //   name: AXPTaskManagementMenuKeys.Cartable,
+            //   text: '@task-management:cartable.menu-title',
+            //   type: 'menu',
+            //   icon: 'fa-light fa-inbox',
+            //   path: `${this.sessionService.application?.name}/${RootConfig.module.name}/cartable`,
+            //   policy: {
+            //     features: [module.name],
+            //   },
+            // },
+            // {
+            //   name: AXPTaskManagementMenuKeys.Root,
+            //   priority: 9003,
+            //   text: '@task-management:root-menu',
+            //   icon: module.icon,
+            //   children: [
+            //     {
+            //       name: AXPTaskManagementMenuKeys.Tasks,
+            //       text: '@task-management:task.plural-title',
+            //       path: this.entityService.createPath(module.name, RootConfig.entities.task.name),
+            //       icon: RootConfig.entities.task.icon,
+            //       priority: 1,
+            //     },
+            //     {
+            //       name: AXPTaskManagementMenuKeys.TaskTemplates,
+            //       text: '@task-management:task-template.plural-title',
+            //       path: this.entityService.createPath(module.name, RootConfig.entities.taskTemplate.name),
+            //       icon: RootConfig.entities.taskTemplate.icon,
+            //       priority: 2,
+            //     },
+            //     {
+            //       text: ``,
+            //       type: 'break',
+            //       priority: 5,
+            //     },
+            //     {
+            //       name: AXPTaskManagementMenuKeys.TaskTypes,
+            //       text: '@task-management:task-type.plural-title',
+            //       path: this.entityService.createPath(module.name, RootConfig.entities.taskType.name),
+            //       icon: RootConfig.entities.taskType.icon,
+            //       priority: 6,
+            //     },
+            //   ],
+            // },
+        ]);
+        context.find(AXPCommonMenuKeys.Projects).addItems([
+            {
+                name: `${AXPTaskManagementMenuKeys.TaskTypes}:divider`,
+                text: '',
+                type: 'break',
+                priority: 5,
+            },
+            {
+                name: AXPTaskManagementMenuKeys.TaskTypes,
+                text: RootConfig.entities.taskType.titlePlural,
+                icon: RootConfig.entities.taskType.icon,
+                priority: 10,
+                path: this.entityService.createPath(module.name, RootConfig.entities.taskType.name),
+                policy: {
+                    features: [module.name],
+                    permissions: [keys.Setup],
+                },
+            },
+        ]);
+    }
+    async resolveTaskBoardMenuPath(applicationName, moduleName) {
+        const userSettings = this.settingsService.scope(AXPPlatformScope.User);
+        const [viewMode, calendarLayout, timelineLayout, tableLayout] = await Promise.all([
+            userSettings.get(AXMTaskBoardSettings.ViewMode),
+            userSettings.get(AXMTaskBoardSettings.CalendarLayout),
+            userSettings.get(AXMTaskBoardSettings.TimelineLayout),
+            userSettings.get(AXMTaskBoardSettings.TableLayout),
+        ]);
+        return buildTaskBoardMenuPath(applicationName, moduleName, viewMode, {
+            calendar: calendarLayout,
+            timeline: timelineLayout,
+            table: tableLayout,
+        });
+    }
+}
+
+//#region ---- Imports ----
+//#endregion
+//#region ---- Settings Provider ----
+const I18N = `@${RootConfig.config.i18n}:settings`;
+class AXMSettingProvider {
+    async provide(context) {
+        context
+            .addGroup('task-management', `${I18N}.task-management.group.nav-title`, `${I18N}.task-management.group.description`, RootConfig.module.icon, `${I18N}.task-management.group.title`, 90)
+            .addSection('taskboard', `${I18N}.task-management.taskboard.section.title`, `${I18N}.task-management.taskboard.section.description`)
+            .addSetting({
+            key: AXMTaskBoardSettings.VisibleCalendar,
+            title: `${I18N}.task-management.taskboard.parts.calendar.title`,
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: true,
+            widget: { type: AXPWidgetsList.Editors.ToggleSwitch },
+            description: `${I18N}.task-management.taskboard.parts.calendar.description`,
+        })
+            .addSetting({
+            key: AXMTaskBoardSettings.VisibleTimeline,
+            title: `${I18N}.task-management.taskboard.parts.timeline.title`,
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: true,
+            widget: { type: AXPWidgetsList.Editors.ToggleSwitch },
+            description: `${I18N}.task-management.taskboard.parts.timeline.description`,
+        })
+            .addSetting({
+            key: AXMTaskBoardSettings.VisibleTable,
+            title: `${I18N}.task-management.taskboard.parts.table.title`,
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: true,
+            widget: { type: AXPWidgetsList.Editors.ToggleSwitch },
+            description: `${I18N}.task-management.taskboard.parts.table.description`,
+        })
+            .addSetting({
+            key: AXMTaskBoardSettings.VisibleKanban,
+            title: `${I18N}.task-management.taskboard.parts.kanban.title`,
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: true,
+            widget: { type: AXPWidgetsList.Editors.ToggleSwitch },
+            description: `${I18N}.task-management.taskboard.parts.kanban.description`,
+        })
+            .addSetting({
+            key: AXMTaskBoardSettings.ColorBy,
+            title: `${I18N}.task-management.taskboard.color-by.title`,
+            scope: 'U',
+            overridableAt: [],
+            isInherited: true,
+            defaultValue: 'dueDate',
+            widget: {
+                type: AXPWidgetsList.Editors.SelectBox,
+                options: {
+                    valueField: 'name',
+                    textField: 'title',
+                    dataSource: [
+                        { name: 'dueDate', title: `${I18N}.task-management.taskboard.color-by.due-date` },
+                        { name: 'priority', title: `${I18N}.task-management.taskboard.color-by.priority` },
+                        { name: 'status', title: `${I18N}.task-management.taskboard.color-by.status` },
+                    ],
+                },
+            },
+            description: `${I18N}.task-management.taskboard.color-by.description`,
+        })
+            .endSection()
+            .endGroup();
+    }
+}
+//#endregion
+
+class AXMSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+        // {
+        //   group: 'command',
+        //  title: 'New Form Template',
+        //  icon: RootConfig.entities.template.icon,
+        //  description: 'Create a new form template for designing reusable forms.', // Added description
+        //  commands: {
+        //    'create-entity': {
+        //      entity: `${RootConfig.module.name}.${RootConfig.entities.template.name}`,
+        //    },
+        //  },
+        // }
+        ];
+    }
+}
+
+//#endregion
+//#region ---- Constants ----
+const WORKFLOW_DEFINITION = 'WorkflowManagement.WorkflowDefinition';
+//#endregion
+//#region ---- Provider ----
+class AXMTaskManagementCatalogScopeDefinitionProvider {
+    async items() {
+        return [
+            {
+                name: TASK_MANAGEMENT_CATALOG_SCOPE_TASKS,
+                title: '@task-management:catalog-scopes.tasks.title',
+                description: '@task-management:catalog-scopes.tasks.description',
+                targets: [WORKFLOW_DEFINITION],
+                icon: 'fa-light fa-clipboard-check',
+                cssClass: 'primary-lighter-surface',
+                order: 20,
+            },
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskManagementCatalogScopeDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskManagementCatalogScopeDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskManagementCatalogScopeDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMTaskFeatureModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskFeatureModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskFeatureModule, imports: [CommonModule, AXPRuntimeModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskFeatureModule, providers: [
+            provideCommandSetups([
+                {
+                    key: AXPTaskManagementCommandKeys.Task.StartFlow,
+                    command: () => import('./acorex-platform-module-task-management-client-start-task-flow.command-ChCuTFV-.mjs').then((c) => c.StartTaskFlowCommand),
+                },
+            ]),
+        ], imports: [CommonModule, AXPRuntimeModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskFeatureModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, AXPRuntimeModule],
+                    providers: [
+                        provideCommandSetups([
+                            {
+                                key: AXPTaskManagementCommandKeys.Task.StartFlow,
+                                command: () => import('./acorex-platform-module-task-management-client-start-task-flow.command-ChCuTFV-.mjs').then((c) => c.StartTaskFlowCommand),
+                            },
+                        ]),
+                    ],
+                }]
+        }] });
+
+class AXMTaskManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskManagementModule, imports: [CommonModule,
+            AXPTaskBoardModule,
+            AXMCalendarManagementModule,
+            AXPWidgetCoreModule,
+            AXMTaskFeatureModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskManagementModule, providers: [
+            {
+                provide: AXP_MODULE_MANIFEST_PROVIDER,
+                useValue: TaskManagementManifest,
+                multi: true,
+            },
+            {
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                useClass: AXMPermissionDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMTaskManagementMenuProvider,
+                multi: true,
+            },
+            {
+                // useExisting keeps a single root instance (avoids a second copy that never refreshes).
+                provide: AXP_TASK_BADGE_PROVIDERS,
+                useExisting: AXMTaskBoardBadgeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXMSettingProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SEARCH_PROVIDER,
+                useClass: AXMSearchCommandProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMTaskManagementWidgetsProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                useClass: AXMTaskManagementCatalogScopeDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_WORKFLOW_TASK_PROVIDER,
+                multi: true,
+                useClass: AXPTaskManagementEntityTaskProvider,
+            },
+        ], imports: [CommonModule,
+            AXPTaskBoardModule,
+            AXMCalendarManagementModule,
+            AXPWidgetCoreModule,
+            AXMTaskFeatureModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMTaskManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        AXPTaskBoardModule,
+                        AXMCalendarManagementModule,
+                        AXPWidgetCoreModule,
+                        AXMTaskFeatureModule,
+                    ],
+                    providers: [
+                        {
+                            provide: AXP_MODULE_MANIFEST_PROVIDER,
+                            useValue: TaskManagementManifest,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            useClass: AXMPermissionDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMTaskManagementMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            // useExisting keeps a single root instance (avoids a second copy that never refreshes).
+                            provide: AXP_TASK_BADGE_PROVIDERS,
+                            useExisting: AXMTaskBoardBadgeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXMSettingProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SEARCH_PROVIDER,
+                            useClass: AXMSearchCommandProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMTaskManagementWidgetsProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                            useClass: AXMTaskManagementCatalogScopeDefinitionProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_WORKFLOW_TASK_PROVIDER,
+                            multi: true,
+                            useClass: AXPTaskManagementEntityTaskProvider,
+                        },
+                    ],
+                }]
+        }] });
+
+//#region ----- Imports -----
+//#endregion
+//#region ----- Builders -----
+function buildTaskBoardWidget(id, x, y, size = [6, 4], title = 'Tasks') {
+    const { config, meta } = layoutFromDimensions(id, AXP_TASK_BOARD_DIMENSIONS, { x, y, lg: size });
+    return {
+        config: { ...config, title },
+        node: {
+            type: 'TaskManagement:Widget:Dashboard:TaskBoard',
+            options: { title, maxItems: 10 },
+            meta,
+            name: `TaskManagement:Widget:Dashboard:TaskBoard-${id}`,
+            path: `TaskManagement:Widget:Dashboard:TaskBoard-${id}`,
+        },
+    };
+}
+function buildTaskBoardShortcutWidget(id, x, y, size = [3, 2]) {
+    const { config, meta } = layoutFromDimensions(id, AXP_TASK_BOARD_SHORTCUT_DIMENSIONS, { x, y, lg: size });
+    return {
+        config,
+        node: {
+            type: 'TaskManagement:Widget:Dashboard:TaskBoardShortcut',
+            options: {
+                dateRange: { title: 'This Month', name: 'this-month' },
+            },
+            meta,
+            name: `TaskManagement:Widget:Dashboard:TaskBoardShortcut-${id}`,
+            path: `TaskManagement:Widget:Dashboard:TaskBoardShortcut-${id}`,
+        },
+    };
+}
+//#endregion
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { buildTaskBoardShortcutWidget as $, AXMTaskBoardViewModel as A, AXM_TASK_VIEW_ALL_PERMISSION as B, AXPDueStatusProvider as C, AXPTASK_PRIORITIES as D, AXPTaskBoardModule as E, AXPTaskBoardShortcut as F, AXPTaskBoardShortcutViewComponent as G, AXPTaskBoardWidget as H, AXPTaskBoardWidgetViewComponent as I, AXPTaskManagementEntityTaskProvider as J, AXPTaskPopoverComponent as K, AXPWorkflowTaskProvider as L, AXP_DUE_STATUS_PROVIDERS as M, AXP_TASK_BOARD_DIMENSIONS as N, AXP_TASK_BOARD_SHORTCUT_DIMENSIONS as O, AXP_TASK_MANAGEMENT_DASHBOARD_SUB_BOARD as P, AXP_TASK_MANAGEMENT_DASHBOARD_SUB_SHORTCUT as Q, AXP_TASK_MANAGEMENT_DASHBOARD_WIDGET_CATEGORY as R, AXP_WORKFLOW_TASK_PROVIDER as S, TASK_BOARD_GRID_ROW_ACTION_COLUMN_WIDTH as T, AXP_WORKFLOW_TASK_PROVIDER_RESOLVER as U, RESET_TASK_BOARD_FILTERS_ASSIGN_TO_CURRENT_USER_COMMAND_KEY as V, ResetTaskBoardFiltersAssignToCurrentUserCommand as W, TASK_BOARD_GRID_ROW_VIEW_ACTION as X, TASK_PRIORITY_ORDER as Y, buildTaskAccentCssClass as Z, buildTaskAccentSurfaceCssClass as _, AXPTaskBoardService as a, buildTaskBoardWidget as a0, buildTaskSurfaceCssClass as a1, formatTaskI18nParamsForTranslate as a2, getDefaultDueStatusDefinitions as a3, getTaskDueStatusKey as a4, getTaskPriorityColor as a5, getTaskPriorityFilterKey as a6, getTaskTranslationKey as a7, hasTaskBoardSavedAssigneePreference as a8, mapEntityStatusColorForBadge as a9, matchesTaskBoardAssigneeFilter as aa, matchesTaskBoardAssigneeUserIdsFilter as ab, matchesTaskDueStatusFilter as ac, matchesTaskPriorityFilter as ad, normalizePriorityFilterKey as ae, normalizePriorityFilterKeys as af, normalizeTaskPriority as ag, resolveDefaultTaskStatusColor as ah, resolveDueStatusFromDefinitions as ai, resolveTaskBoardAccentColor as aj, resolveTaskBoardCalendarPlacement as ak, resolveTaskBoardSavedAssigneeIds as al, resolveTaskBoardSchedulingRange as am, resolveTaskBoardStatusColor as an, resolveTaskPopoverComponent as ao, taskOverlapsFilterRange as ap, AXMTaskBoardTaskPopoverOverlayService as b, TASK_BOARD_GRID_ROW_ACTION_ITEMS as c, AXPDueStatusProviderService as d, canViewAllTaskAssignees as e, filterTasksOverlappingRange as f, getTaskBoardLayoutOptions as g, normalizeTaskTypeFilterNames as h, enrichTaskBoardTasks as i, isTaskBoardRangeFilterCategory as j, deriveTaskBoardDateRangeFromNavigator as k, applyTaskBoardDateRangeToViewModel as l, resolveTaskBoardCategoryLayoutFromQuery as m, normalizeTaskBoardAssigneeIds as n, resolveTaskBoardCurrentUserAssigneeItem as o, AXM_TASK_BOARD_UNASSIGNED_ASSIGNEE_ID as p, isTaskBoardUnassignedAssigneeId as q, resolveTaskBoardSchedulerLabels as r, AXMDefaultDueStatusProvider as s, AXMSearchCommandProvider as t, usesTaskBoardToolbarNavigator as u, AXMSettingProvider as v, AXMTaskBoardDefaultTaskPopoverComponent as w, AXMTaskBoardTaskPopoverShellComponent as x, AXMTaskManagementMenuProvider as y, AXMTaskManagementModule as z };
+//# sourceMappingURL=acorex-platform-module-task-management-client-acorex-platform-module-task-management-client-CIwafWli.mjs.map