verben-authentication-ui 1.1.0 → 1.1.1

package/README.md

@@ -1,7 +1,29 @@
-# VerbenNgUi
+# VerbenAuthenticationUi
 
 This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 18.2.0.
 
+## Theming
+
+This library is theme-aware: its component styles read the `verben-ng-ui`
+`--vbn-*` CSS custom properties instead of hardcoded colors, so it automatically
+follows whatever theme the host application configures. It ships **no** theme
+config of its own (no `theme.css`, no `forRoot()`) — that is the host app's job.
+
+**Host requirement:** the consuming application must load
+`node_modules/verben-ng-ui/styles/theme.css` (which requires `verben-ng-ui@>=1.3.0`,
+matching this library's peer dependency) and call `VerbenUiModule.forRoot({...})`
+once. See that package's `INTEGRATION.md` for the full multi-layer setup.
+
+Translucent greys and tints (e.g. `#66666680`, `rgba(0, 0, 0, 0.25)`) are
+intentionally left as literals — mapping them onto solid tokens would drop their
+alpha channel.
+
+**Two files here are generated, not hand-written:**
+`src/theme/tailwind.css` is Tailwind output built by `npm run build:lib:tailwind`
+and `@import`ed by the user-management and user-request-approval component styles.
+Never hand-edit it — change the templates and regenerate, or you will produce
+malformed escaped selectors that silently match nothing.
+
 ## Code scaffolding
 
 Run `ng generate component component-name --project verben-authentication-ui` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project verben-authentication-ui`.

package/esm2022/src/lib/base/core/base-data-page.facade.mjs

@@ -0,0 +1,215 @@
+import { Injectable } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { ErrorResponse } from 'verben-authentication-ui/src/lib/models';
+import * as i0 from "@angular/core";
+import * as i1 from "./base-data-page.state";
+import * as i2 from "./base-data-page.service";
+import * as i3 from "../handlers/search-handler.service";
+import * as i4 from "verben-authentication-ui/src/lib/services";
+/**
+ * Abstract facade for base data pages.
+ * Orchestrates state, service, and search handler, and surfaces the host app's
+ * busy indicator / toasts through UtilService.
+ */
+export class BaseDataPageFacade {
+    state;
+    service;
+    searchHandler;
+    utilService;
+    config;
+    destroy$ = new Subject();
+    cardSelectionCleared = new Subject();
+    constructor(state, service, searchHandler, utilService, config) {
+        this.state = state;
+        this.service = service;
+        this.searchHandler = searchHandler;
+        this.utilService = utilService;
+        this.config = config;
+        this.initializeSearchHandler();
+        this.state.setVisibleColumns(this.config.columns);
+        if (this.config.cardDataMapper) {
+            this.state.setCardDataMapper(this.config.cardDataMapper);
+        }
+        // Drive the host busy indicator from the shared loading flag.
+        this.state
+            .isUpdating$()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((loading) => this.utilService.sendBI(loading));
+    }
+    // ===== Configuration =====
+    getConfig() {
+        return this.config;
+    }
+    getColumns() {
+        return this.config.columns;
+    }
+    // ===== Observables =====
+    get items$() {
+        return this.state.getItems$();
+    }
+    get isLoading$() {
+        return this.state.isUpdating$();
+    }
+    get totalCount$() {
+        return this.state.getTotalCount$();
+    }
+    get filters$() {
+        return this.state.getFilters$();
+    }
+    get sorts$() {
+        return this.state.getSorts$();
+    }
+    get searchTerm$() {
+        return this.state.getSearchTerm$();
+    }
+    get visibleColumns$() {
+        return this.state.getVisibleColumns$();
+    }
+    get cardData() {
+        return this.state.getCardData();
+    }
+    get currentCardData() {
+        return this.state.getCurrentCardData();
+    }
+    /**
+     * Emits when a refetch invalidates the current card selection.
+     * Card views listen to this to clear their own selection state.
+     */
+    get cardSelectionCleared$() {
+        return this.cardSelectionCleared.asObservable();
+    }
+    // ===== Data Loading =====
+    async loadData() {
+        this.clearCardSelection();
+        this.state.setUpdating(true);
+        this.state.clearItems();
+        this.state.resetPagination();
+        const params = this.state.getQueryParamsValue();
+        const filters = this.state.getFiltersValue();
+        const sorts = this.state.getSortsValue();
+        const searchTerm = this.state.getSearchTermValue();
+        const result = await this.service.getData(params.skip, params.limit, filters, sorts, searchTerm, this.config.columns);
+        this.state.setUpdating(false);
+        if (result instanceof ErrorResponse) {
+            this.utilService.showError(result.ErrorMsg);
+            return;
+        }
+        this.state.setItems(result.Result || []);
+        this.state.setTotalCount(result.Total || 0);
+    }
+    addItem(item) {
+        this.state.addItem(item);
+    }
+    async loadMore() {
+        this.state.setUpdating(true);
+        this.state.incrementPagination();
+        const params = this.state.getQueryParamsValue();
+        const filters = this.state.getFiltersValue();
+        const sorts = this.state.getSortsValue();
+        const searchTerm = this.state.getSearchTermValue();
+        const result = await this.service.getData(params.skip, params.limit, filters, sorts, searchTerm, this.config.columns);
+        this.state.setUpdating(false);
+        if (result instanceof ErrorResponse) {
+            this.utilService.showError(result.ErrorMsg);
+            return;
+        }
+        this.state.appendItems(result.Result || []);
+    }
+    async refresh() {
+        await this.loadData();
+    }
+    // ===== Search =====
+    onSearch(term) {
+        this.searchHandler.search(term);
+    }
+    initializeSearchHandler() {
+        if (this.config.searchDebounceTime) {
+            this.searchHandler.setDebounceTime(this.config.searchDebounceTime);
+        }
+        this.searchHandler.search$.pipe(takeUntil(this.destroy$)).subscribe((term) => {
+            this.state.setSearchTerm(term);
+            this.loadData();
+        });
+    }
+    // ===== Filters / Sorts =====
+    async applyFilters(filters) {
+        this.state.setFilters(filters);
+        await this.loadData();
+    }
+    async clearFilters() {
+        this.state.clearFilters();
+        await this.loadData();
+    }
+    async applySorts(sorts) {
+        this.state.setSorts(sorts);
+        await this.loadData();
+    }
+    async clearSorts() {
+        this.state.clearSorts();
+        await this.loadData();
+    }
+    // ===== Visible Columns =====
+    updateVisibleColumns(columns) {
+        this.state.setVisibleColumns(columns);
+    }
+    // ===== Card Data =====
+    selectCard(cardData) {
+        this.state.setCurrentCardData(cardData);
+    }
+    /**
+     * Drop the current card selection because the data it referred to is being
+     * replaced. Called by loadData(); deliberately not by loadMore(), which only
+     * appends and leaves an existing selection valid.
+     */
+    clearCardSelection() {
+        this.state.setCurrentCardData(null);
+        this.cardSelectionCleared.next();
+    }
+    // ===== CRUD =====
+    async saveItems(items) {
+        this.state.setUpdating(true);
+        const result = await this.service.saveItems(items);
+        this.state.setUpdating(false);
+        if (result instanceof ErrorResponse) {
+            this.utilService.showError(result.ErrorMsg);
+            return false;
+        }
+        this.utilService.showSuccess('Record(s) saved successfully');
+        result.forEach((savedItem) => this.state.upsertItem(savedItem));
+        return true;
+    }
+    async deleteItems(itemIds) {
+        this.state.setUpdating(true);
+        const result = await this.service.deleteItems(itemIds);
+        this.state.setUpdating(false);
+        if (result instanceof ErrorResponse) {
+            this.utilService.showError(result.ErrorMsg);
+            return false;
+        }
+        itemIds.forEach((id) => this.state.removeItem(id));
+        return true;
+    }
+    // ===== Export =====
+    async exportData() {
+        const filters = this.state.getFiltersValue();
+        const sorts = this.state.getSortsValue();
+        const searchTerm = this.state.getSearchTermValue();
+        const result = await this.service.exportData(filters, sorts, searchTerm, this.config.columns);
+        if (result instanceof ErrorResponse) {
+            return [];
+        }
+        return result;
+    }
+    // ===== Cleanup =====
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.cardSelectionCleared.complete();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseDataPageFacade, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseDataPageFacade });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseDataPageFacade, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.BaseDataPageState }, { type: i2.BaseDataPageService }, { type: i3.SearchHandlerService }, { type: i4.UtilService }, { type: undefined }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-data-page.facade.js","sourceRoot":"","sources":["../../../../../../../projects/verben-authentication-ui/src/lib/base/core/base-data-page.facade.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy, WritableSignal } from '@angular/core';\nimport { Observable, Subject, takeUntil } from 'rxjs';\nimport { BaseModel, ErrorResponse } from 'verben-authentication-ui/src/lib/models';\nimport { UtilService } from 'verben-authentication-ui/src/lib/services';\nimport { CardData, ColumnDefinition, FilterCondition, SortCondition } from 'verben-ng-ui';\nimport { SearchHandlerService } from '../handlers/search-handler.service';\nimport { BasePageConfig } from '../models/page-config.interface';\nimport { BaseDataPageService } from './base-data-page.service';\nimport { BaseDataPageState } from './base-data-page.state';\n\n/**\n * Abstract facade for base data pages.\n * Orchestrates state, service, and search handler, and surfaces the host app's\n * busy indicator / toasts through UtilService.\n */\n@Injectable()\nexport abstract class BaseDataPageFacade<T extends BaseModel> implements OnDestroy {\n  private destroy$ = new Subject<void>();\n  private cardSelectionCleared = new Subject<void>();\n\n  constructor(\n    protected state: BaseDataPageState<T>,\n    protected service: BaseDataPageService<T>,\n    protected searchHandler: SearchHandlerService,\n    protected utilService: UtilService,\n    protected config: BasePageConfig<T>,\n  ) {\n    this.initializeSearchHandler();\n    this.state.setVisibleColumns(this.config.columns);\n\n    if (this.config.cardDataMapper) {\n      this.state.setCardDataMapper(this.config.cardDataMapper);\n    }\n\n    // Drive the host busy indicator from the shared loading flag.\n    this.state\n      .isUpdating$()\n      .pipe(takeUntil(this.destroy$))\n      .subscribe((loading) => this.utilService.sendBI(loading));\n  }\n\n  // ===== Configuration =====\n\n  getConfig(): BasePageConfig<T> {\n    return this.config;\n  }\n\n  getColumns(): ColumnDefinition<T>[] {\n    return this.config.columns;\n  }\n\n  // ===== Observables =====\n\n  get items$(): Observable<T[]> {\n    return this.state.getItems$();\n  }\n\n  get isLoading$(): Observable<boolean> {\n    return this.state.isUpdating$();\n  }\n\n  get totalCount$(): Observable<number> {\n    return this.state.getTotalCount$();\n  }\n\n  get filters$(): Observable<FilterCondition[]> {\n    return this.state.getFilters$();\n  }\n\n  get sorts$(): Observable<SortCondition[]> {\n    return this.state.getSorts$();\n  }\n\n  get searchTerm$(): Observable<string> {\n    return this.state.getSearchTerm$();\n  }\n\n  get visibleColumns$(): Observable<ColumnDefinition<T>[]> {\n    return this.state.getVisibleColumns$();\n  }\n\n  get cardData(): WritableSignal<CardData[]> {\n    return this.state.getCardData();\n  }\n\n  get currentCardData(): WritableSignal<CardData | null> {\n    return this.state.getCurrentCardData();\n  }\n\n  /**\n   * Emits when a refetch invalidates the current card selection.\n   * Card views listen to this to clear their own selection state.\n   */\n  get cardSelectionCleared$(): Observable<void> {\n    return this.cardSelectionCleared.asObservable();\n  }\n\n  // ===== Data Loading =====\n\n  async loadData(): Promise<void> {\n    this.clearCardSelection();\n    this.state.setUpdating(true);\n    this.state.clearItems();\n    this.state.resetPagination();\n\n    const params = this.state.getQueryParamsValue();\n    const filters = this.state.getFiltersValue();\n    const sorts = this.state.getSortsValue();\n    const searchTerm = this.state.getSearchTermValue();\n\n    const result = await this.service.getData(\n      params.skip,\n      params.limit,\n      filters,\n      sorts,\n      searchTerm,\n      this.config.columns,\n    );\n\n    this.state.setUpdating(false);\n\n    if (result instanceof ErrorResponse) {\n      this.utilService.showError(result.ErrorMsg);\n      return;\n    }\n\n    this.state.setItems(result.Result || []);\n    this.state.setTotalCount(result.Total || 0);\n  }\n\n  addItem(item: T): void {\n    this.state.addItem(item);\n  }\n\n  async loadMore(): Promise<void> {\n    this.state.setUpdating(true);\n    this.state.incrementPagination();\n\n    const params = this.state.getQueryParamsValue();\n    const filters = this.state.getFiltersValue();\n    const sorts = this.state.getSortsValue();\n    const searchTerm = this.state.getSearchTermValue();\n\n    const result = await this.service.getData(\n      params.skip,\n      params.limit,\n      filters,\n      sorts,\n      searchTerm,\n      this.config.columns,\n    );\n\n    this.state.setUpdating(false);\n\n    if (result instanceof ErrorResponse) {\n      this.utilService.showError(result.ErrorMsg);\n      return;\n    }\n\n    this.state.appendItems(result.Result || []);\n  }\n\n  async refresh(): Promise<void> {\n    await this.loadData();\n  }\n\n  // ===== Search =====\n\n  onSearch(term: string): void {\n    this.searchHandler.search(term);\n  }\n\n  private initializeSearchHandler(): void {\n    if (this.config.searchDebounceTime) {\n      this.searchHandler.setDebounceTime(this.config.searchDebounceTime);\n    }\n\n    this.searchHandler.search$.pipe(takeUntil(this.destroy$)).subscribe((term) => {\n      this.state.setSearchTerm(term);\n      this.loadData();\n    });\n  }\n\n  // ===== Filters / Sorts =====\n\n  async applyFilters(filters: FilterCondition[]): Promise<void> {\n    this.state.setFilters(filters);\n    await this.loadData();\n  }\n\n  async clearFilters(): Promise<void> {\n    this.state.clearFilters();\n    await this.loadData();\n  }\n\n  async applySorts(sorts: SortCondition[]): Promise<void> {\n    this.state.setSorts(sorts);\n    await this.loadData();\n  }\n\n  async clearSorts(): Promise<void> {\n    this.state.clearSorts();\n    await this.loadData();\n  }\n\n  // ===== Visible Columns =====\n\n  updateVisibleColumns(columns: ColumnDefinition<T>[]): void {\n    this.state.setVisibleColumns(columns);\n  }\n\n  // ===== Card Data =====\n\n  selectCard(cardData: CardData | null): void {\n    this.state.setCurrentCardData(cardData);\n  }\n\n  /**\n   * Drop the current card selection because the data it referred to is being\n   * replaced. Called by loadData(); deliberately not by loadMore(), which only\n   * appends and leaves an existing selection valid.\n   */\n  protected clearCardSelection(): void {\n    this.state.setCurrentCardData(null);\n    this.cardSelectionCleared.next();\n  }\n\n  // ===== CRUD =====\n\n  async saveItems(items: T[]): Promise<boolean> {\n    this.state.setUpdating(true);\n    const result = await this.service.saveItems(items);\n    this.state.setUpdating(false);\n\n    if (result instanceof ErrorResponse) {\n      this.utilService.showError(result.ErrorMsg);\n      return false;\n    }\n\n    this.utilService.showSuccess('Record(s) saved successfully');\n    result.forEach((savedItem) => this.state.upsertItem(savedItem));\n    return true;\n  }\n\n  async deleteItems(itemIds: string[]): Promise<boolean> {\n    this.state.setUpdating(true);\n    const result = await this.service.deleteItems(itemIds);\n    this.state.setUpdating(false);\n\n    if (result instanceof ErrorResponse) {\n      this.utilService.showError(result.ErrorMsg);\n      return false;\n    }\n\n    itemIds.forEach((id) => this.state.removeItem(id));\n    return true;\n  }\n\n  // ===== Export =====\n\n  async exportData(): Promise<T[]> {\n    const filters = this.state.getFiltersValue();\n    const sorts = this.state.getSortsValue();\n    const searchTerm = this.state.getSearchTermValue();\n\n    const result = await this.service.exportData(\n      filters,\n      sorts,\n      searchTerm,\n      this.config.columns,\n    );\n\n    if (result instanceof ErrorResponse) {\n      return [];\n    }\n\n    return result;\n  }\n\n  // ===== Cleanup =====\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n    this.cardSelectionCleared.complete();\n  }\n}\n"]}

package/esm2022/src/lib/base/core/base-data-page.service.mjs

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import { lastValueFrom } from 'rxjs';
+import { ErrorResponse, } from 'verben-authentication-ui/src/lib/models';
+import * as i0 from "@angular/core";
+import * as i1 from "verben-authentication-ui/src/lib/services";
+import * as i2 from "../handlers/filter-handler.service";
+import * as i3 from "../handlers/sort-handler.service";
+/**
+ * Abstract base service for data pages.
+ * Handles list/search/save/delete with filter and sort support.
+ *
+ * The concrete URLs are built by the protected `*Url` seams below so that
+ * services whose API does not follow the default `Get{Endpoint}/{skip}/{limit}`
+ * conventions (e.g. plural names or a trailing sort suffix) can override just
+ * the URL without reimplementing the request-selection logic in `getData()`.
+ * When `baseUrl` is omitted, HttpWebRequestService falls back to the
+ * AuthenticationAPI base.
+ */
+export class BaseDataPageService {
+    server;
+    filterHandler;
+    sortHandler;
+    baseUrl;
+    constructor(server, filterHandler, sortHandler, baseUrl) {
+        this.server = server;
+        this.filterHandler = filterHandler;
+        this.sortHandler = sortHandler;
+        this.baseUrl = baseUrl;
+    }
+    // ===== URL seams (override in child services when the API deviates) =====
+    listUrl(skip, limit) {
+        return `Get${this.getEndpoint()}/${skip}/${limit}`;
+    }
+    searchTermUrl(term, skip, limit) {
+        return `Get${this.getEndpoint()}WithParam/${term}/${skip}/${limit}`;
+    }
+    filterSearchUrl(skip, limit) {
+        return `Search${this.getEndpoint()}/${skip}/${limit}`;
+    }
+    saveUrl() {
+        return `Save${this.getEndpoint()}`;
+    }
+    deleteUrl(itemIds) {
+        return `${this.getEndpoint()}/${itemIds.join(',')}`;
+    }
+    // ===== Payload =====
+    buildPayload(filters, sorts, columns) {
+        const filterPayload = this.filterHandler.buildFilterPayload(filters, columns);
+        const sortPayload = this.sortHandler.buildSortPayload(sorts, columns);
+        return [...filterPayload, ...sortPayload];
+    }
+    // ===== Reads =====
+    /**
+     * Fetch data, automatically choosing the endpoint based on parameters:
+     * search-only -> GET WithParam, filters/sorts -> POST Search, otherwise plain GET.
+     */
+    async getData(skip, limit, filters, sorts, searchTerm, columns) {
+        const hasFilters = !!filters && filters.length > 0;
+        const hasSorts = !!sorts && sorts.length > 0;
+        if (searchTerm && !hasFilters && !hasSorts) {
+            return this.server.get(this.searchTermUrl(searchTerm, skip, limit), this.baseUrl);
+        }
+        if (hasFilters || hasSorts) {
+            if (!columns) {
+                throw new Error('Columns required for filter/sort operations');
+            }
+            const payload = this.buildPayload(filters || [], sorts || [], columns);
+            return this.server.post(this.filterSearchUrl(skip, limit), payload, this.baseUrl);
+        }
+        return this.server.get(this.listUrl(skip, limit), this.baseUrl);
+    }
+    // ===== Writes =====
+    async saveItems(items) {
+        return this.server.post(this.saveUrl(), items, this.baseUrl);
+    }
+    async deleteItems(itemIds) {
+        // HttpWebRequestService.delete returns a raw observable that rejects on HTTP
+        // error (unlike get/post, which resolve an ErrorResponse), so normalize here
+        // to keep the facade's error-handling contract uniform.
+        try {
+            const result = await lastValueFrom(this.server.delete(this.deleteUrl(itemIds), this.baseUrl));
+            return result ?? false;
+        }
+        catch (err) {
+            const msg = err?.error?.ErrorMsg || err?.ErrorMsg || err?.message || 'Delete failed';
+            return new ErrorResponse(msg);
+        }
+    }
+    // ===== Export =====
+    async exportData(filters, sorts, searchTerm, columns) {
+        const result = await this.getData(0, 999999, filters, sorts, searchTerm, columns);
+        if (result instanceof ErrorResponse) {
+            return result;
+        }
+        return result.Result || [];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseDataPageService, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseDataPageService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseDataPageService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpWebRequestService }, { type: i2.FilterHandlerService }, { type: i3.SortHandlerService }, { type: undefined }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-data-page.service.js","sourceRoot":"","sources":["../../../../../../../projects/verben-authentication-ui/src/lib/base/core/base-data-page.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { lastValueFrom } from 'rxjs';\nimport {\n  BaseModel,\n  ErrorResponse,\n  PagedResult,\n} from 'verben-authentication-ui/src/lib/models';\nimport { HttpWebRequestService } from 'verben-authentication-ui/src/lib/services';\nimport { ColumnDefinition, FilterCondition, SortCondition } from 'verben-ng-ui';\nimport { FilterHandlerService } from '../handlers/filter-handler.service';\nimport { SortHandlerService } from '../handlers/sort-handler.service';\nimport { SearchPropertyValue } from '../models/api-payload';\n\n/**\n * Abstract base service for data pages.\n * Handles list/search/save/delete with filter and sort support.\n *\n * The concrete URLs are built by the protected `*Url` seams below so that\n * services whose API does not follow the default `Get{Endpoint}/{skip}/{limit}`\n * conventions (e.g. plural names or a trailing sort suffix) can override just\n * the URL without reimplementing the request-selection logic in `getData()`.\n * When `baseUrl` is omitted, HttpWebRequestService falls back to the\n * AuthenticationAPI base.\n */\n@Injectable()\nexport abstract class BaseDataPageService<T extends BaseModel> {\n  constructor(\n    protected server: HttpWebRequestService,\n    protected filterHandler: FilterHandlerService,\n    protected sortHandler: SortHandlerService,\n    protected baseUrl?: string,\n  ) {}\n\n  /** API endpoint name (e.g. 'User'). Must be implemented by child classes. */\n  abstract getEndpoint(): string;\n\n  // ===== URL seams (override in child services when the API deviates) =====\n\n  protected listUrl(skip: number, limit: number): string {\n    return `Get${this.getEndpoint()}/${skip}/${limit}`;\n  }\n\n  protected searchTermUrl(term: string, skip: number, limit: number): string {\n    return `Get${this.getEndpoint()}WithParam/${term}/${skip}/${limit}`;\n  }\n\n  protected filterSearchUrl(skip: number, limit: number): string {\n    return `Search${this.getEndpoint()}/${skip}/${limit}`;\n  }\n\n  protected saveUrl(): string {\n    return `Save${this.getEndpoint()}`;\n  }\n\n  protected deleteUrl(itemIds: string[]): string {\n    return `${this.getEndpoint()}/${itemIds.join(',')}`;\n  }\n\n  // ===== Payload =====\n\n  buildPayload(\n    filters: FilterCondition[],\n    sorts: SortCondition[],\n    columns: ColumnDefinition<T>[],\n  ): SearchPropertyValue[] {\n    const filterPayload = this.filterHandler.buildFilterPayload(filters, columns);\n    const sortPayload = this.sortHandler.buildSortPayload(sorts, columns);\n    return [...filterPayload, ...sortPayload];\n  }\n\n  // ===== Reads =====\n\n  /**\n   * Fetch data, automatically choosing the endpoint based on parameters:\n   * search-only -> GET WithParam, filters/sorts -> POST Search, otherwise plain GET.\n   */\n  async getData(\n    skip: number,\n    limit: number,\n    filters?: FilterCondition[],\n    sorts?: SortCondition[],\n    searchTerm?: string,\n    columns?: ColumnDefinition<T>[],\n  ): Promise<PagedResult<T> | ErrorResponse> {\n    const hasFilters = !!filters && filters.length > 0;\n    const hasSorts = !!sorts && sorts.length > 0;\n\n    if (searchTerm && !hasFilters && !hasSorts) {\n      return this.server.get<PagedResult<T>>(\n        this.searchTermUrl(searchTerm, skip, limit),\n        this.baseUrl,\n      );\n    }\n\n    if (hasFilters || hasSorts) {\n      if (!columns) {\n        throw new Error('Columns required for filter/sort operations');\n      }\n      const payload = this.buildPayload(filters || [], sorts || [], columns);\n      return this.server.post<PagedResult<T>>(\n        this.filterSearchUrl(skip, limit),\n        payload,\n        this.baseUrl,\n      );\n    }\n\n    return this.server.get<PagedResult<T>>(this.listUrl(skip, limit), this.baseUrl);\n  }\n\n  // ===== Writes =====\n\n  async saveItems(items: T[]): Promise<T[] | ErrorResponse> {\n    return this.server.post<T[]>(this.saveUrl(), items, this.baseUrl);\n  }\n\n  async deleteItems(itemIds: string[]): Promise<boolean | ErrorResponse> {\n    // HttpWebRequestService.delete returns a raw observable that rejects on HTTP\n    // error (unlike get/post, which resolve an ErrorResponse), so normalize here\n    // to keep the facade's error-handling contract uniform.\n    try {\n      const result = await lastValueFrom(\n        this.server.delete<boolean>(this.deleteUrl(itemIds), this.baseUrl),\n      );\n      return result ?? false;\n    } catch (err: any) {\n      const msg =\n        err?.error?.ErrorMsg || err?.ErrorMsg || err?.message || 'Delete failed';\n      return new ErrorResponse(msg);\n    }\n  }\n\n  // ===== Export =====\n\n  async exportData(\n    filters?: FilterCondition[],\n    sorts?: SortCondition[],\n    searchTerm?: string,\n    columns?: ColumnDefinition<T>[],\n  ): Promise<T[] | ErrorResponse> {\n    const result = await this.getData(0, 999999, filters, sorts, searchTerm, columns);\n    if (result instanceof ErrorResponse) {\n      return result;\n    }\n    return result.Result || [];\n  }\n}\n"]}

package/esm2022/src/lib/base/core/base-data-page.state.mjs

@@ -0,0 +1,203 @@
+import { signal } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { SortDirection, } from 'verben-authentication-ui/src/lib/models';
+/**
+ * Abstract state management for base data pages.
+ * Tracks items, loading state, query params, filters, sorts, search, and
+ * visible columns. Card data is held in signals for cheap change detection.
+ */
+export class BaseDataPageState {
+    updating$ = new BehaviorSubject(false);
+    items$ = new BehaviorSubject([]);
+    totalCount$ = new BehaviorSubject(0);
+    queryParams$ = new BehaviorSubject({
+        skip: 0,
+        limit: 20,
+        sortOrder: SortDirection.Asc,
+    });
+    searchTerm$ = new BehaviorSubject('');
+    filters$ = new BehaviorSubject([]);
+    sorts$ = new BehaviorSubject([]);
+    visibleColumns$ = new BehaviorSubject([]);
+    cardData = signal([]);
+    currentCardData = signal(null);
+    cardDataMapper;
+    /**
+     * Stable identity for a record. The auth models key on uppercase `Id`/`Code`
+     * and only sometimes carry a lowercase `id`, so match across all three rather
+     * than assuming one is populated.
+     */
+    getItemKey(item) {
+        return item.Id || item.id || item.Code;
+    }
+    updateCardDataFromItems(items) {
+        if (this.cardDataMapper) {
+            this.cardData.set(items.map((item) => this.cardDataMapper(item)));
+        }
+    }
+    // ===== Loading State =====
+    isUpdating$() {
+        return this.updating$.asObservable();
+    }
+    setUpdating(isUpdating) {
+        this.updating$.next(isUpdating);
+    }
+    // ===== Items =====
+    getItems$() {
+        return this.items$.asObservable();
+    }
+    getItemsValue() {
+        return this.items$.getValue();
+    }
+    setItems(items) {
+        this.items$.next(items);
+        this.updateCardDataFromItems(items);
+    }
+    appendItems(newItems) {
+        const allItems = [...this.items$.getValue(), ...newItems];
+        this.items$.next(allItems);
+        this.updateCardDataFromItems(allItems);
+    }
+    addItem(item) {
+        const allItems = [item, ...this.items$.getValue()];
+        this.items$.next(allItems);
+        this.updateCardDataFromItems(allItems);
+    }
+    updateItem(updatedItem) {
+        const items = this.items$.getValue();
+        const key = this.getItemKey(updatedItem);
+        const index = items.findIndex((item) => this.getItemKey(item) === key);
+        if (index !== -1) {
+            items[index] = updatedItem;
+            const allItems = [...items];
+            this.items$.next(allItems);
+            this.updateCardDataFromItems(allItems);
+        }
+    }
+    /** Update the item when its key already exists, otherwise prepend it. */
+    upsertItem(item) {
+        const key = this.getItemKey(item);
+        const exists = this.items$
+            .getValue()
+            .some((existing) => this.getItemKey(existing) === key);
+        if (exists) {
+            this.updateItem(item);
+        }
+        else {
+            this.addItem(item);
+        }
+    }
+    removeItem(itemKey) {
+        const filteredItems = this.items$
+            .getValue()
+            .filter((item) => this.getItemKey(item) !== itemKey);
+        this.items$.next(filteredItems);
+        this.updateCardDataFromItems(filteredItems);
+    }
+    clearItems() {
+        this.items$.next([]);
+        this.updateCardDataFromItems([]);
+    }
+    // ===== Total Count =====
+    getTotalCount$() {
+        return this.totalCount$.asObservable();
+    }
+    setTotalCount(count) {
+        this.totalCount$.next(count);
+    }
+    // ===== Query Parameters =====
+    getQueryParams$() {
+        return this.queryParams$.asObservable();
+    }
+    getQueryParamsValue() {
+        return this.queryParams$.getValue();
+    }
+    updateQueryParams(params) {
+        this.queryParams$.next({ ...this.queryParams$.getValue(), ...params });
+    }
+    resetPagination() {
+        this.queryParams$.next({ ...this.queryParams$.getValue(), skip: 0 });
+    }
+    incrementPagination() {
+        const currentParams = this.queryParams$.getValue();
+        this.queryParams$.next({
+            ...currentParams,
+            skip: currentParams.skip + currentParams.limit,
+        });
+    }
+    // ===== Search =====
+    getSearchTerm$() {
+        return this.searchTerm$.asObservable();
+    }
+    getSearchTermValue() {
+        return this.searchTerm$.getValue();
+    }
+    setSearchTerm(term) {
+        this.searchTerm$.next(term);
+    }
+    // ===== Filters =====
+    getFilters$() {
+        return this.filters$.asObservable();
+    }
+    getFiltersValue() {
+        return this.filters$.getValue();
+    }
+    setFilters(filters) {
+        this.filters$.next(filters);
+    }
+    clearFilters() {
+        this.filters$.next([]);
+    }
+    // ===== Sorts =====
+    getSorts$() {
+        return this.sorts$.asObservable();
+    }
+    getSortsValue() {
+        return this.sorts$.getValue();
+    }
+    setSorts(sorts) {
+        this.sorts$.next(sorts);
+    }
+    clearSorts() {
+        this.sorts$.next([]);
+    }
+    // ===== Visible Columns =====
+    getVisibleColumns$() {
+        return this.visibleColumns$.asObservable();
+    }
+    getVisibleColumnsValue() {
+        return this.visibleColumns$.getValue();
+    }
+    setVisibleColumns(columns) {
+        this.visibleColumns$.next(columns);
+    }
+    // ===== Card Data =====
+    setCardDataMapper(mapper) {
+        this.cardDataMapper = mapper;
+    }
+    getCardData() {
+        return this.cardData;
+    }
+    setCardData(data) {
+        this.cardData.set(data);
+    }
+    getCurrentCardData() {
+        return this.currentCardData;
+    }
+    setCurrentCardData(data) {
+        this.currentCardData.set(data);
+    }
+    // ===== Reset All =====
+    reset() {
+        this.clearItems();
+        this.setSearchTerm('');
+        this.clearFilters();
+        this.clearSorts();
+        this.setVisibleColumns([]);
+        this.cardData.set([]);
+        this.currentCardData.set(null);
+        this.resetPagination();
+        this.setTotalCount(0);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-data-page.state.js","sourceRoot":"","sources":["../../../../../../../projects/verben-authentication-ui/src/lib/base/core/base-data-page.state.ts"],"names":[],"mappings":"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","sourcesContent":["import { signal, WritableSignal } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport {\n  BaseModel,\n  QueryParams,\n  SortDirection,\n} from 'verben-authentication-ui/src/lib/models';\nimport { CardData, ColumnDefinition, FilterCondition, SortCondition } from 'verben-ng-ui';\n\n/**\n * Abstract state management for base data pages.\n * Tracks items, loading state, query params, filters, sorts, search, and\n * visible columns. Card data is held in signals for cheap change detection.\n */\nexport abstract class BaseDataPageState<T extends BaseModel> {\n  protected updating$ = new BehaviorSubject<boolean>(false);\n\n  protected items$ = new BehaviorSubject<T[]>([]);\n  protected totalCount$ = new BehaviorSubject<number>(0);\n\n  protected queryParams$ = new BehaviorSubject<QueryParams<T>>({\n    skip: 0,\n    limit: 20,\n    sortOrder: SortDirection.Asc,\n  });\n\n  protected searchTerm$ = new BehaviorSubject<string>('');\n\n  protected filters$ = new BehaviorSubject<FilterCondition[]>([]);\n  protected sorts$ = new BehaviorSubject<SortCondition[]>([]);\n\n  protected visibleColumns$ = new BehaviorSubject<ColumnDefinition<T>[]>([]);\n\n  protected cardData = signal<CardData[]>([]);\n  protected currentCardData = signal<CardData | null>(null);\n\n  protected cardDataMapper?: (item: T) => CardData;\n\n  /**\n   * Stable identity for a record. The auth models key on uppercase `Id`/`Code`\n   * and only sometimes carry a lowercase `id`, so match across all three rather\n   * than assuming one is populated.\n   */\n  protected getItemKey(item: T): string {\n    return item.Id || item.id || item.Code;\n  }\n\n  protected updateCardDataFromItems(items: T[]): void {\n    if (this.cardDataMapper) {\n      this.cardData.set(items.map((item) => this.cardDataMapper!(item)));\n    }\n  }\n\n  // ===== Loading State =====\n\n  isUpdating$(): Observable<boolean> {\n    return this.updating$.asObservable();\n  }\n\n  setUpdating(isUpdating: boolean): void {\n    this.updating$.next(isUpdating);\n  }\n\n  // ===== Items =====\n\n  getItems$(): Observable<T[]> {\n    return this.items$.asObservable();\n  }\n\n  getItemsValue(): T[] {\n    return this.items$.getValue();\n  }\n\n  setItems(items: T[]): void {\n    this.items$.next(items);\n    this.updateCardDataFromItems(items);\n  }\n\n  appendItems(newItems: T[]): void {\n    const allItems = [...this.items$.getValue(), ...newItems];\n    this.items$.next(allItems);\n    this.updateCardDataFromItems(allItems);\n  }\n\n  addItem(item: T): void {\n    const allItems = [item, ...this.items$.getValue()];\n    this.items$.next(allItems);\n    this.updateCardDataFromItems(allItems);\n  }\n\n  updateItem(updatedItem: T): void {\n    const items = this.items$.getValue();\n    const key = this.getItemKey(updatedItem);\n    const index = items.findIndex((item) => this.getItemKey(item) === key);\n    if (index !== -1) {\n      items[index] = updatedItem;\n      const allItems = [...items];\n      this.items$.next(allItems);\n      this.updateCardDataFromItems(allItems);\n    }\n  }\n\n  /** Update the item when its key already exists, otherwise prepend it. */\n  upsertItem(item: T): void {\n    const key = this.getItemKey(item);\n    const exists = this.items$\n      .getValue()\n      .some((existing) => this.getItemKey(existing) === key);\n    if (exists) {\n      this.updateItem(item);\n    } else {\n      this.addItem(item);\n    }\n  }\n\n  removeItem(itemKey: string): void {\n    const filteredItems = this.items$\n      .getValue()\n      .filter((item) => this.getItemKey(item) !== itemKey);\n    this.items$.next(filteredItems);\n    this.updateCardDataFromItems(filteredItems);\n  }\n\n  clearItems(): void {\n    this.items$.next([]);\n    this.updateCardDataFromItems([]);\n  }\n\n  // ===== Total Count =====\n\n  getTotalCount$(): Observable<number> {\n    return this.totalCount$.asObservable();\n  }\n\n  setTotalCount(count: number): void {\n    this.totalCount$.next(count);\n  }\n\n  // ===== Query Parameters =====\n\n  getQueryParams$(): Observable<QueryParams<T>> {\n    return this.queryParams$.asObservable();\n  }\n\n  getQueryParamsValue(): QueryParams<T> {\n    return this.queryParams$.getValue();\n  }\n\n  updateQueryParams(params: Partial<QueryParams<T>>): void {\n    this.queryParams$.next({ ...this.queryParams$.getValue(), ...params });\n  }\n\n  resetPagination(): void {\n    this.queryParams$.next({ ...this.queryParams$.getValue(), skip: 0 });\n  }\n\n  incrementPagination(): void {\n    const currentParams = this.queryParams$.getValue();\n    this.queryParams$.next({\n      ...currentParams,\n      skip: currentParams.skip + currentParams.limit,\n    });\n  }\n\n  // ===== Search =====\n\n  getSearchTerm$(): Observable<string> {\n    return this.searchTerm$.asObservable();\n  }\n\n  getSearchTermValue(): string {\n    return this.searchTerm$.getValue();\n  }\n\n  setSearchTerm(term: string): void {\n    this.searchTerm$.next(term);\n  }\n\n  // ===== Filters =====\n\n  getFilters$(): Observable<FilterCondition[]> {\n    return this.filters$.asObservable();\n  }\n\n  getFiltersValue(): FilterCondition[] {\n    return this.filters$.getValue();\n  }\n\n  setFilters(filters: FilterCondition[]): void {\n    this.filters$.next(filters);\n  }\n\n  clearFilters(): void {\n    this.filters$.next([]);\n  }\n\n  // ===== Sorts =====\n\n  getSorts$(): Observable<SortCondition[]> {\n    return this.sorts$.asObservable();\n  }\n\n  getSortsValue(): SortCondition[] {\n    return this.sorts$.getValue();\n  }\n\n  setSorts(sorts: SortCondition[]): void {\n    this.sorts$.next(sorts);\n  }\n\n  clearSorts(): void {\n    this.sorts$.next([]);\n  }\n\n  // ===== Visible Columns =====\n\n  getVisibleColumns$(): Observable<ColumnDefinition<T>[]> {\n    return this.visibleColumns$.asObservable();\n  }\n\n  getVisibleColumnsValue(): ColumnDefinition<T>[] {\n    return this.visibleColumns$.getValue();\n  }\n\n  setVisibleColumns(columns: ColumnDefinition<T>[]): void {\n    this.visibleColumns$.next(columns);\n  }\n\n  // ===== Card Data =====\n\n  setCardDataMapper(mapper: (item: T) => CardData): void {\n    this.cardDataMapper = mapper;\n  }\n\n  getCardData(): WritableSignal<CardData[]> {\n    return this.cardData;\n  }\n\n  setCardData(data: CardData[]): void {\n    this.cardData.set(data);\n  }\n\n  getCurrentCardData(): WritableSignal<CardData | null> {\n    return this.currentCardData;\n  }\n\n  setCurrentCardData(data: CardData | null): void {\n    this.currentCardData.set(data);\n  }\n\n  // ===== Reset All =====\n\n  reset(): void {\n    this.clearItems();\n    this.setSearchTerm('');\n    this.clearFilters();\n    this.clearSorts();\n    this.setVisibleColumns([]);\n    this.cardData.set([]);\n    this.currentCardData.set(null);\n    this.resetPagination();\n    this.setTotalCount(0);\n  }\n}\n"]}