@devopmaat/badaboom 1.1.1

package/lib/_theme.scss

@@ -0,0 +1,32 @@
+@use 'sass:map';
+@use './common/alert/bdb-alert-theme';
+@use './common/boolean-display/bdb-boolean-display-theme';
+@use './application/common/query-input/bdb-query-input-theme';
+@use './application/common/search/bdb-search-theme';
+@use './application/common/table/bdb-table-theme';
+@use './common/button-theme';
+@use './common/icon-theme';
+
+@function define-light-theme($mat-theme, $warn-palette, $danger-palette, $success-palette, $info-palette) {
+  @return map.deep-merge(
+    $mat-theme,
+    (
+      color: (
+        warn: $warn-palette,
+        danger: $danger-palette,
+        success: $success-palette,
+        info: $info-palette,
+      ),
+    )
+  );
+}
+
+@mixin all-component-themes($bdb-theme) {
+  @include bdb-alert-theme.theme($bdb-theme);
+  @include bdb-boolean-display-theme.theme($bdb-theme);
+  @include bdb-query-input-theme.theme($bdb-theme);
+  @include bdb-search-theme.theme($bdb-theme);
+  @include bdb-table-theme.theme($bdb-theme);
+  @include button-theme.theme($bdb-theme);
+  @include icon-theme.theme($bdb-theme);
+}

package/lib/application/common/bdb-data-source.d.ts

@@ -0,0 +1,25 @@
+import { DataSource } from '@angular/cdk/collections';
+import { BdbEntityRead } from '../../domain/common/entities/bdb-entity-read';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { BdbResponse } from '../../domain/common/bdb-response';
+import { HttpErrorResponse } from '@angular/common/http';
+import { BdbRequest } from '../../domain/common/bdb-request';
+import { BdbServiceR } from '../../domain/common/services/bdb-service-r';
+import { BdbEntity } from '../../domain/common/entities/bdb-entity';
+export declare class BdbDataSource<TEntityRead extends BdbEntityRead> implements DataSource<TEntityRead> {
+    private service;
+    dataSubject: BehaviorSubject<TEntityRead[]>;
+    private responseSubject;
+    private loadingSubject;
+    private errorSubject;
+    loading$: Observable<boolean>;
+    error$: Observable<HttpErrorResponse | null>;
+    response$: Observable<BdbResponse<TEntityRead>>;
+    readonly request: BdbRequest;
+    get data(): TEntityRead[];
+    constructor(service: BdbServiceR<BdbEntity, TEntityRead>, initialRequest?: BdbRequest);
+    disconnect(): void;
+    connect(): Observable<TEntityRead[] | readonly TEntityRead[]>;
+    loadMethod(service: BdbServiceR<BdbEntity, TEntityRead>, request: BdbRequest): Observable<BdbResponse<TEntityRead>>;
+    load(): void;
+}

package/lib/application/common/paginator/bdb-paginator.component.d.ts

@@ -0,0 +1,17 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { PageEvent } from '@angular/material/paginator';
+import { BdbEntityRead } from '../../../domain/common/entities/bdb-entity-read';
+import { BdbDataSource } from '../bdb-data-source';
+import * as i0 from "@angular/core";
+export declare class BdbPaginatorComponent<TEntityRead extends BdbEntityRead> implements OnInit, OnDestroy {
+    dataSource: BdbDataSource<TEntityRead>;
+    private _onDestroy;
+    pageSize?: number;
+    page?: number;
+    length?: number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    changePage(event: PageEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbPaginatorComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbPaginatorComponent<any>, "bdb-paginator", never, { "dataSource": { "alias": "dataSource"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/application/common/query-input/_bdb-query-input-theme.scss

@@ -0,0 +1,17 @@
+@use 'sass:map';
+@use '@angular/material' as mat;
+
+@mixin theme($theme) {
+  $color-config: mat.m2-get-color-config($theme);
+
+  $background-palette: map.get($color-config, background);
+  $primary-palette: map.get($color-config, primary);
+
+  .khi-query-input {
+    background: mat.m2-get-color-from-palette($background-palette, card);
+    border: 1px solid rgba(0, 0, 0, 0.12);
+    &:focus-within {
+      border-color: mat.m2-get-color-from-palette($primary-palette, default);
+    }
+  }
+}

package/lib/application/common/query-input/bdb-query-input.component.d.ts

@@ -0,0 +1,15 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { BdbEntityRead } from '../../../domain/common/entities/bdb-entity-read';
+import { BdbDataSource } from '../bdb-data-source';
+import * as i0 from "@angular/core";
+export declare class BdbQueryInputComponent<TEntityRead extends BdbEntityRead> implements OnInit, OnDestroy {
+    class: string;
+    dataSource: BdbDataSource<TEntityRead>;
+    private _onDestroy;
+    queryFormControl: FormControl<string | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbQueryInputComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbQueryInputComponent<any>, "bdb-query-input[dataSource]", never, { "dataSource": { "alias": "dataSource"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/application/common/search/_bdb-search-theme.scss

@@ -0,0 +1,12 @@
+@use 'sass:map';
+@use '@angular/material' as mat;
+
+@mixin theme($theme) {
+  $color-config: mat.m2-get-color-config($theme);
+
+  $foreground-palette: map.get($color-config, foreground);
+
+  .search-icon-disabled {
+    color: mat.m2-get-color-from-palette($foreground-palette, disabled-button);
+  }
+}

package/lib/application/common/search/bdb-search-wrapper.component.d.ts

@@ -0,0 +1,13 @@
+import { OnInit } from '@angular/core';
+import { ControlContainer, FormControl } from '@angular/forms';
+import { BdbEntityRead } from '../../../domain/common/entities/bdb-entity-read';
+import * as i0 from "@angular/core";
+export declare abstract class BdbSearchWrapperBaseComponent<TEntityRead extends BdbEntityRead> implements OnInit {
+    controlName?: string;
+    control?: FormControl<TEntityRead | null>;
+    formControl: FormControl<TEntityRead | null>;
+    controlContainer: ControlContainer;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbSearchWrapperBaseComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbSearchWrapperBaseComponent<any>, "ng-component", never, { "controlName": { "alias": "controlName"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/application/common/search/bdb-search.component.d.ts

@@ -0,0 +1,43 @@
+import { CollectionViewer, ListRange } from '@angular/cdk/collections';
+import { AfterViewInit, ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor, FormControl, NgControl } from '@angular/forms';
+import { MatAutocompleteSelectedEvent, MatAutocompleteTrigger } from '@angular/material/autocomplete';
+import { MatIconButton } from '@angular/material/button';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { BdbEntityRead } from '../../../domain/common/entities/bdb-entity-read';
+import { BdbDataSource } from '../bdb-data-source';
+import * as i0 from "@angular/core";
+export declare class BdbSearchComponent<TEntityRead extends BdbEntityRead> implements CollectionViewer, OnInit, AfterViewInit, OnDestroy, ControlValueAccessor {
+    ngControl: NgControl;
+    dataSource: BdbDataSource<TEntityRead>;
+    displayFn: (_: TEntityRead | string) => string;
+    label: string;
+    hint: string;
+    placeholder: string;
+    searchInput?: ElementRef<HTMLInputElement>;
+    clearButton?: MatIconButton;
+    autoCompleteTrigger?: MatAutocompleteTrigger;
+    private readonly _onDestroy;
+    viewChange: BehaviorSubject<ListRange>;
+    searchOptions?: Observable<TEntityRead[] | readonly TEntityRead[]>;
+    searchCtrl: FormControl<string | TEntityRead>;
+    inputTabIndex: number;
+    hasValue: boolean;
+    isDisabled: boolean;
+    onChange?: (_: TEntityRead | null) => void;
+    onTouch?: () => void;
+    constructor(ngControl: NgControl);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    writeValue(obj: TEntityRead | null): void;
+    registerOnChange(fn: (_: TEntityRead | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onFocus(): void;
+    onBlur(): void;
+    selectOption(event: MatAutocompleteSelectedEvent): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbSearchComponent<any>, [{ optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbSearchComponent<any>, "bdb-search", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "displayFn": { "alias": "displayFn"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/application/common/table/_bdb-table-theme.scss

@@ -0,0 +1,48 @@
+@use 'sass:map';
+@use '@angular/material' as mat;
+
+@mixin theme($theme) {
+  $color-config: mat.m2-get-color-config($theme);
+  $paletteNames: (primary, accent, warn, danger, success, info);
+  $info-default: mat.m2-get-color-from-palette(map.get($color-config, info), default);
+
+  .bdb-table {
+    tbody tr {
+      &.selected {
+        background-color: rgba($info-default, 0.12);
+      }
+
+      @each $paletteName in $paletteNames {
+        $bg: mat.m2-get-color-from-palette(map.get($color-config, $paletteName), default);
+        &.bdb-#{$paletteName} {
+          background-color: rgba($bg, 0.04);
+          &.selected {
+            background-color: rgba($bg, 0.12);
+          }
+        }
+      }
+    }
+
+    &.is-clickable tbody tr {
+      &:hover {
+        background-color: rgba($info-default, 0.08);
+      }
+      &.selected:hover {
+        background-color: rgba($info-default, 0.16);
+      }
+
+      @each $paletteName in $paletteNames {
+        $bg: mat.m2-get-color-from-palette(map.get($color-config, $paletteName), default);
+
+        &.bdb-#{$paletteName} {         
+          &:hover {
+            background-color: rgba($bg, 0.08);
+          }
+          &.selected:hover {
+            background-color: rgba($bg, 0.16);
+          }
+        }
+      }
+    }
+  }
+}

package/lib/application/common/table/bdb-cell.directive.d.ts

@@ -0,0 +1,9 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class BdbCellDirective {
+    templateRef: TemplateRef<never>;
+    bdbCellDef: string;
+    constructor(templateRef: TemplateRef<never>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BdbCellDirective, "ng-template[bdbCellDef]", never, { "bdbCellDef": { "alias": "bdbCellDef"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/application/common/table/bdb-column-builder.d.ts

@@ -0,0 +1,18 @@
+import { BdbBooleanColumnOptions, BdbColumnOptions, BdbCurrencyColumnOptions, BdbDateColumnOptions, BdbEnumColumnOptions, BdbNumberColumnOptions, BdbPercentageColumnOptions, BdbStringColumnOptions } from './bdb-column-options';
+import { BdbColumn } from './bdb-column';
+import { BdbEntityRead } from '../../../domain/common/entities/bdb-entity-read';
+import * as i0 from "@angular/core";
+export declare class BdbColumnBuilder<TRead extends BdbEntityRead> {
+    build(...columns: BdbColumn<TRead, unknown>[]): BdbColumn<TRead, unknown>[];
+    string(field: (x: TRead) => string | undefined, title: string, options?: BdbStringColumnOptions): BdbColumn<TRead, string | undefined>;
+    number(field: (x: TRead) => number | undefined, title: string, options?: BdbNumberColumnOptions): BdbColumn<TRead, number | undefined>;
+    percentage(field: (x: TRead) => number | undefined, title: string, options?: BdbPercentageColumnOptions): BdbColumn<TRead, number | undefined>;
+    currency(field: (x: TRead) => number | undefined, title: string, options?: BdbCurrencyColumnOptions): BdbColumn<TRead, number | undefined>;
+    date(field: (x: TRead) => Date | undefined, title: string, options?: BdbDateColumnOptions): BdbColumn<TRead, Date | undefined>;
+    boolean(field: (x: TRead) => boolean | undefined, title: string, options?: BdbBooleanColumnOptions): BdbColumn<TRead, boolean | undefined>;
+    enum<TEnum>(field: (x: TRead) => TEnum | undefined, title: string, options?: BdbEnumColumnOptions): BdbColumn<TRead, TEnum | undefined>;
+    custom(id: string, title: string, options?: BdbColumnOptions): BdbColumn<TRead, unknown>;
+    private _buildCommonOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbColumnBuilder<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BdbColumnBuilder<any>>;
+}

package/lib/application/common/table/bdb-column-options.d.ts

@@ -0,0 +1,32 @@
+import { PipeTransform, Type } from '@angular/core';
+export interface BdbColumnOptions {
+    id?: string;
+    sortDisabled?: boolean;
+    width?: number;
+    textAlign?: 'start' | 'end';
+}
+export interface BdbBooleanColumnOptions extends BdbColumnOptions {
+    icon?: boolean;
+}
+export interface BdbDateColumnOptions extends BdbColumnOptions {
+    format?: string;
+}
+export interface BdbEnumColumnOptions extends BdbColumnOptions {
+    pipe?: Type<PipeTransform>;
+}
+export interface BdbNumberColumnOptions extends BdbColumnOptions {
+    format?: string;
+}
+export interface BdbPercentageColumnOptions extends BdbColumnOptions {
+    digitsInfo?: string;
+    locale?: string;
+}
+export interface BdbCurrencyColumnOptions extends BdbColumnOptions {
+    currencyCode?: string;
+    display?: string;
+    digitsInfo?: string;
+    locale?: string;
+}
+export interface BdbStringColumnOptions extends BdbColumnOptions {
+    pipe?: Type<PipeTransform>;
+}

package/lib/application/common/table/bdb-column-type.d.ts

@@ -0,0 +1,10 @@
+export declare enum BdbColumnType {
+    String = "String",
+    Number = "Number",
+    Percentage = "Percentage",
+    Currency = "Currency",
+    Date = "Date",
+    Boolean = "Boolean",
+    Enum = "Enum",
+    Custom = "Custom"
+}

package/lib/application/common/table/bdb-column.d.ts

@@ -0,0 +1,19 @@
+import { PipeTransform, TemplateRef, Type } from '@angular/core';
+import { BdbColumnType } from './bdb-column-type';
+export interface BdbColumn<TRead, TField> {
+    template?: TemplateRef<never> | undefined;
+    field: (x: TRead) => TField;
+    type: BdbColumnType;
+    id: string;
+    title: string;
+    sortDisabled?: boolean;
+    width?: number;
+    textAlign?: 'start' | 'end';
+    format?: string;
+    icon?: boolean;
+    pipe?: Type<PipeTransform>;
+    currencyCode?: string;
+    display?: string;
+    digitsInfo?: string;
+    locale?: string;
+}

package/lib/application/common/table/bdb-context-action.d.ts

@@ -0,0 +1,7 @@
+export interface BdbContextAction<TRead> {
+    icon: string;
+    color: string;
+    label: string;
+    identifier: string;
+    condition?: (x: TRead) => boolean;
+}

package/lib/application/common/table/bdb-table.component.d.ts

@@ -0,0 +1,57 @@
+import { AfterContentInit, EventEmitter, OnChanges, OnDestroy, OnInit, QueryList, TrackByFunction } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { Sort } from '@angular/material/sort';
+import { SelectionModel } from '@angular/cdk/collections';
+import { BdbEntity } from '../../../domain/common/entities/bdb-entity';
+import { BdbColumn } from './bdb-column';
+import { BdbDataSource } from '../bdb-data-source';
+import { BdbContextAction } from './bdb-context-action';
+import { BdbCellDirective } from './bdb-cell.directive';
+import { BdbColumnType } from './bdb-column-type';
+import { BdbPalette } from '../../../common/bdb-palette';
+import * as i0 from "@angular/core";
+export declare class BdbTableComponent<TRead extends BdbEntity> implements OnInit, OnChanges, AfterContentInit, OnDestroy {
+    private readonly _onDestroy;
+    columns: BdbColumn<TRead, unknown>[];
+    dataSource: BdbDataSource<TRead>;
+    displayedColumns: string[];
+    contextActions: BdbContextAction<TRead>[];
+    selection?: SelectionModel<TRead>;
+    selectOnRowClick: boolean;
+    selectedRowClass: string;
+    isClickable: boolean;
+    rowClick: EventEmitter<TRead>;
+    contextAction: EventEmitter<{
+        action: BdbContextAction<TRead>;
+        row: TRead;
+    }>;
+    contextMenu: MatMenuTrigger;
+    cellTemplates: QueryList<BdbCellDirective> | undefined;
+    error: HttpErrorResponse | undefined;
+    columnType: typeof BdbColumnType;
+    contextMenuPosition: {
+        x: string;
+        y: string;
+    };
+    rowColor?: (x: TRead) => BdbPalette;
+    trackById: TrackByFunction<BdbEntity>;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    load(): void;
+    setColumnTemplates(): void;
+    onRowClick(row: TRead): void;
+    sortData(event: Sort): void;
+    onContextMenu(event: MouseEvent, row: TRead): void;
+    onContextMenuAction(action: BdbContextAction<TRead>, row: TRead): void;
+    isAllSelected(): boolean;
+    anySelected(): boolean;
+    toggleAllRows(): void;
+    rowClass(row: TRead): {
+        [klass: string]: unknown;
+    } | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BdbTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BdbTableComponent<any>, "bdb-table[dataSource]", never, { "columns": { "alias": "columns"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "contextActions": { "alias": "contextActions"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "selectOnRowClick": { "alias": "selectOnRowClick"; "required": false; }; "selectedRowClass": { "alias": "selectedRowClass"; "required": false; }; "isClickable": { "alias": "isClickable"; "required": false; }; "rowColor": { "alias": "rowColor"; "required": false; }; }, { "rowClick": "rowClick"; "contextAction": "contextAction"; }, ["cellTemplates"], ["*"], true, never>;
+}

package/lib/application/common/table/dynamic.pipe.d.ts

@@ -0,0 +1,9 @@
+import { Injector, PipeTransform, Type } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DynamicPipe implements PipeTransform {
+    private injector;
+    constructor(injector: Injector);
+    transform(value: unknown, requiredPipe: Type<PipeTransform>, pipeArgs: unknown): unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DynamicPipe, "dynamicPipe", true>;
+}

package/lib/application/exception-log/exception-log-table/exception-log-table.component.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from '@angular/core';
+import { ExceptionLogRead } from '../../../domain/entities/exception-log/exception-log-read';
+import { BdbDataSource } from '../../common/bdb-data-source';
+import { BdbColumnBuilder } from '../../common/table/bdb-column-builder';
+import { BdbContextAction } from '../../common/table/bdb-context-action';
+import { ActivatedRoute, Router } from '@angular/router';
+import { BdbColumn } from '../../common/table/bdb-column';
+import * as i0 from "@angular/core";
+export declare class ExceptionLogTableComponent {
+    private cb;
+    private router;
+    private activatedRoute;
+    dataSource: BdbDataSource<ExceptionLogRead>;
+    displayedColumns: string[];
+    rowClick: EventEmitter<ExceptionLogRead>;
+    columns: BdbColumn<ExceptionLogRead, unknown>[];
+    constructor(cb: BdbColumnBuilder<ExceptionLogRead>, router: Router, activatedRoute: ActivatedRoute);
+    contextActions: BdbContextAction<ExceptionLogRead>[];
+    onRowClick(row: ExceptionLogRead): void;
+    onContextAction(event: {
+        action: BdbContextAction<ExceptionLogRead>;
+        row: ExceptionLogRead;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExceptionLogTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ExceptionLogTableComponent, "bdb-exception-log-table[dataSource]", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "contextActions": { "alias": "contextActions"; "required": false; }; }, { "rowClick": "rowClick"; }, never, never, true, never>;
+}

package/lib/application/task-log/task-log-outcome.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { TaskLogOutcome } from '../../domain/enums/task-log-outcome';
+import * as i0 from "@angular/core";
+export declare class TaskLogOutcomePipe implements PipeTransform {
+    transform(value: TaskLogOutcome): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogOutcomePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TaskLogOutcomePipe, "taskLogOutcome", true>;
+}

package/lib/application/task-log/task-log-status.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { TaskLogStatus } from '../../domain/enums/task-log-status';
+import * as i0 from "@angular/core";
+export declare class TaskLogStatusPipe implements PipeTransform {
+    transform(value: TaskLogStatus): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogStatusPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TaskLogStatusPipe, "taskLogStatus", true>;
+}

package/lib/application/task-log-parameter/task-log-parameter-value.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import { TaskLogParameter } from '../../domain/entities/task-log-parameter/task-log-parameter';
+import * as i0 from "@angular/core";
+export declare class TaskLogParameterValuePipe implements PipeTransform {
+    private locale;
+    constructor(locale: string);
+    transform(value: TaskLogParameter): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskLogParameterValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TaskLogParameterValuePipe, "taskLogParameterValue", true>;
+}

package/lib/application/user/user-table/user-table.component.d.ts

@@ -0,0 +1,25 @@
+import { EventEmitter } from '@angular/core';
+import { BdbDataSource } from '../../common/bdb-data-source';
+import { UserRead } from '../../../domain/entities/user/user-read';
+import { MatDialog } from '@angular/material/dialog';
+import { BdbColumnBuilder } from '../../common/table/bdb-column-builder';
+import { BdbContextAction } from '../../common/table/bdb-context-action';
+import { BdbColumn } from '../../common/table/bdb-column';
+import * as i0 from "@angular/core";
+export declare class UserTableComponent {
+    private matDialog;
+    private cb;
+    dataSource: BdbDataSource<UserRead>;
+    displayedColumns: string[];
+    rowClick: EventEmitter<UserRead>;
+    columns: BdbColumn<UserRead, unknown>[];
+    constructor(matDialog: MatDialog, cb: BdbColumnBuilder<UserRead>);
+    contextActions: BdbContextAction<UserRead>[];
+    onRowClick(user: UserRead): void;
+    onContextAction(event: {
+        action: BdbContextAction<UserRead>;
+        row: UserRead;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserTableComponent, "bdb-user-table[dataSource]", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; }; "contextActions": { "alias": "contextActions"; "required": false; }; }, { "rowClick": "rowClick"; }, never, never, true, never>;
+}

package/lib/bdb-auth-options.d.ts

@@ -0,0 +1,28 @@
+export interface BdbAuthOptions {
+    loginPath: string;
+    logoutPath: string;
+    accessDeniedPath: string;
+    forgotPasswordPath: string;
+    resetPasswordPath: string;
+    invalidTokenPath: string;
+    addPresentation: boolean;
+}
+export declare class BdbAuthOptionsBuilder {
+    private _loginPath?;
+    private _logoutPath?;
+    private _accessDeniedPath?;
+    private _forgotPasswordPath?;
+    private _resetPasswordPath?;
+    private _invalidTokenPath?;
+    private _addPresentation;
+    constructor(configure: BdbAuthOptionsConfigure);
+    set loginPath(path: string);
+    set logoutPath(path: string);
+    set accessDeniedPath(path: string);
+    set forgotPasswordPath(path: string);
+    set resetPasswordPath(path: string);
+    set invalidTokenPath(path: string);
+    addPresentation(): void;
+    build(): BdbAuthOptions;
+}
+export type BdbAuthOptionsConfigure = (_: BdbAuthOptionsBuilder) => void;

package/lib/bdb-options.d.ts

@@ -0,0 +1,16 @@
+import { InjectionToken } from '@angular/core';
+import { BdbAuthOptions, BdbAuthOptionsConfigure } from './bdb-auth-options';
+export interface BdbOptions {
+    backendUrl: string;
+    authOptions?: BdbAuthOptions;
+}
+export declare class BdbOptionsBuilder {
+    private _backendUrl;
+    private _auth?;
+    constructor(configure: BdbOptionsConfigure);
+    set backendUrl(url: string);
+    addAuth(configure: BdbAuthOptionsConfigure): void;
+    build(): BdbOptions;
+}
+export type BdbOptionsConfigure = (_: BdbOptionsBuilder) => void;
+export declare const BDB_OPTIONS: InjectionToken<BdbOptions>;

package/lib/common/_button-theme.scss

@@ -0,0 +1,87 @@
+@use 'sass:map';
+@use 'sass:meta';
+@use '@angular/material' as mat;
+
+$_ripple-opacity: 0.1;
+
+// Applies the background color for a ripple. If the value provided is not a Sass color,
+// we assume that we've been given a CSS variable. Since we can't perform alpha-blending
+// on a CSS variable, we instead add the opacity directly to the ripple element.
+@mixin _ripple-background($palette, $hue, $opacity) {
+  $background-color: mat.m2-get-color-from-palette($palette, $hue, $opacity);
+  background-color: $background-color;
+  @if (meta.type-of($background-color) != color) {
+    opacity: $opacity;
+  }
+}
+
+@mixin _ripple-color($theme, $hue, $opacity: $_ripple-opacity) {
+  $warn: map.get($theme, warn);
+  $danger: map.get($theme, danger);
+  $success: map.get($theme, success);
+  $info: map.get($theme, info);
+
+  &.mat-warn .mat-ripple-element {
+    @include _ripple-background($warn, $hue, $opacity);
+  }
+
+  &.mat-danger .mat-ripple-element {
+    @include _ripple-background($danger, $hue, $opacity);
+  }
+
+  &.mat-success .mat-ripple-element {
+    @include _ripple-background($success, $hue, $opacity);
+  }
+
+  &.mat-info .mat-ripple-element {
+    @include _ripple-background($info, $hue, $opacity);
+  }
+}
+
+// Applies a property to an mat-button element for each of the supported palettes.
+@mixin _theme-property($theme, $property, $hue) {
+  $danger: map.get($theme, danger);
+  $success: map.get($theme, success);
+  $info: map.get($theme, info);
+  $warn: map.get($theme, warn);
+  $background: map.get($theme, background);
+  $foreground: map.get($theme, foreground);
+
+  &.mat-warn {
+    #{$property}: mat.m2-get-color-from-palette($warn, $hue);
+  }
+  &.mat-danger {
+    #{$property}: mat.m2-get-color-from-palette($danger, $hue);
+  }
+  &.mat-success {
+    #{$property}: mat.m2-get-color-from-palette($success, $hue);
+  }
+  &.mat-info {
+    #{$property}: mat.m2-get-color-from-palette($info, $hue);
+  }
+  &[disabled] {
+    $palette: if($property == 'color', $foreground, $background);
+    #{$property}: mat.m2-get-color-from-palette($palette, disabled-button);
+  }
+}
+
+@mixin theme($config-or-theme) {
+  $config: mat.m2-get-color-config($config-or-theme);
+
+  .mat-mdc-button-base {
+    &.mat-mdc-button,
+    &.mat-mdc-icon-button,
+    &.mat-mdc-outlined-button {
+      @include _theme-property($config, 'color', text);
+    }
+
+    &.mat-mdc-unelevated-button,
+    &.mat-mdc-raised-button,
+    &.mat-mdc-fab,
+    &.mat-mdc-mini-fab {
+      @include _theme-property($config, 'color', default-contrast);
+      @include _theme-property($config, 'background-color', default);
+      @include _ripple-color($config, default-contrast);
+    }
+  }
+}