@yuuvis/client-framework 2.20.1 → 3.0.0-beta.20.0

package/actions/index.d.ts

@@ -1,9 +1,230 @@
-export * from './lib/actions.module';
-export * from './lib/actions.service';
-export * from './lib/actions/delete-action/delete-action';
-export * from './lib/actions/download-action/download-action';
-export * from './lib/actions.interface';
-export * from './lib/actions.icon';
-export * from './lib/components/contextmenu/contextmenu.component';
-export * from './lib/components/contextmenu/contextmenu.model';
-export * from './lib/components/contextmenu/contextmenuTrigger.directive';
+import * as i0 from '@angular/core';
+import { Signal, TemplateRef } from '@angular/core';
+import * as i1 from '@angular/common';
+import * as i2 from '@ngx-translate/core';
+import { MatIconRegistry } from '@angular/material/icon';
+import { DmsObject } from '@yuuvis/client-core';
+import { Observable } from 'rxjs';
+import { CdkMenu, CdkMenuItem, CdkContextMenuTrigger } from '@angular/cdk/menu';
+
+/**
+ * Module for the actions library.
+ */
+declare class ActionsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ActionsModule, never, [typeof i1.CommonModule, typeof i2.TranslateModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ActionsModule>;
+}
+
+type ActionClass = {
+    new (...args: any[]): any;
+};
+declare class AbstractContextAction {
+    context?: ActionContext;
+    constructor(context?: ActionContext);
+}
+interface BaseAction {
+    /**
+     * Equals the selector of the actions selector (will be set by the action service)
+     */
+    id: string;
+    /**
+     * label to be displayed inside the action menu
+     */
+    label: string;
+    /**
+     * description to be displayed inside the action menu
+     */
+    description?: string;
+    /**
+     * @ignore
+     */
+    icon: string;
+    /**
+     * actions priority defining the position of the action within the whole list of actions
+     */
+    priority: number;
+    /**
+     * group of actions the action should be part of ('common' or 'further')
+     */
+    group: string;
+    /**
+     * number of selected items supported by the action
+     * (SelectionRange.SINGLE_SELECT, SelectionRange.MULTI_SELECT, SelectionRange.MULTI_SELECT_ONLY )
+     */
+    range: SelectionRange;
+    /**
+     * Types that are supported by the action
+     */
+    supports: ActionSupport;
+    /**
+     * Determining whether or not the action is executable for the given selection
+     * @param item Current selection
+     * @returns true if the action is executable for the current selection, false otherwise
+     */
+    isExecutable: (items: DmsObject[]) => Observable<boolean>;
+}
+interface ActionSupport {
+    types?: string[];
+    sots?: string[];
+    pattern?: string;
+}
+interface ActionContext {
+    /**
+     * As actions deal with DmsObjects the subject property is the property that
+     * should be used to display the name of the object. This may be used for
+     * showing the name of the object in a confirmation/error dialog or similar.
+     */
+    subjectProperty?: string;
+    /**
+     * The appId is the id of the application that the action is executed in.
+     */
+    appId?: string;
+}
+interface Action extends BaseAction {
+    run: (items: DmsObject[]) => Observable<boolean>;
+}
+interface ActionOptions {
+    context?: ActionContext;
+    exclude?: string[] | RegExp;
+}
+declare enum SelectionRange {
+    SINGLE_SELECT = 0,
+    MULTI_SELECT = 1,
+    MULTI_SELECT_ONLY = 2,
+    ANY = 3
+}
+declare const BASE_ACTION: {
+    copy: string;
+    cut: string;
+    download: string;
+    delete: string;
+};
+
+declare class ActionsService {
+    private readonly injector;
+    private dialog;
+    readonly iconRegistry: MatIconRegistry;
+    private _registeredActions;
+    /**
+     * Registers actions that can be used in the application.
+     * @param a Array of actions to register, each action must have an id and a
+     * class that extends ActionClass
+     */
+    registerActions(a: {
+        id: string;
+        action: ActionClass;
+    }[]): void;
+    /**
+     * Conceals actions that are no longer needed or should not be available.
+     * This will remove the actions from the registered actions list.
+     * @param actionIDs  Array of action IDs to conceal
+     */
+    concealActions(actionIDs: string[]): void;
+    /**
+     * Returns all actions that are executable for the given selection.
+     * @param selection Array of DmsObjects to check for executable actions
+     * @param options options to filter the actions
+     * @returns Observable of actions that are executable for the given selection
+     */
+    getActions(selection: DmsObject[], options?: ActionOptions): Observable<Action[]>;
+    /**
+     * Get all available actions. This includes the default actions and all registered actions but
+     * without checking if they are executable.
+     * @param context Context passed to the actions
+     * @returns Array of available actions
+     */
+    getAvailableActions(context?: ActionContext): Action[];
+    getActionsForType(objectTypeId: string, context?: ActionContext): Action[];
+    getActionById(id: string, context?: ActionContext): Action | undefined;
+    getActionsById(ids: string[], context?: ActionContext): Action[];
+    openContextMenu(actions: Signal<Action[]>, callback: (action: Action) => void, overlayOrigin: {
+        x: number;
+        y: number;
+    }): void;
+    private _actionsSupportsType;
+    /**
+     * Registers a set of default actions that are commonly used in the application.
+     * These actions include delete, download, copy and cut. This method can be called
+     * during the initialization of the application to ensure that these actions
+     * are available for use.
+     */
+    registerDefaultActions(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionsService>;
+}
+
+declare class DeleteAction extends AbstractContextAction implements Action {
+    #private;
+    private translate;
+    private retention;
+    id: string;
+    label: any;
+    description: any;
+    priority: number;
+    icon: string;
+    group: string;
+    range: SelectionRange;
+    supports: ActionSupport;
+    isExecutable(items: DmsObject[]): Observable<boolean>;
+    run(items: DmsObject[]): Observable<boolean>;
+}
+
+declare class DownloadAction extends AbstractContextAction implements Action {
+    private translate;
+    private dmsService;
+    id: string;
+    label: any;
+    description: any;
+    priority: number;
+    icon: string;
+    group: string;
+    range: SelectionRange;
+    supports: ActionSupport;
+    isExecutable(selection: DmsObject[]): Observable<boolean>;
+    run(selection: DmsObject[]): Observable<boolean>;
+}
+
+declare const ACTION_ICON: {
+    download: string;
+    delete: string;
+    copy: string;
+    cut: string;
+    manageFlavor: string;
+};
+
+interface ContextMenuAction extends Action {
+    iconName?: string;
+    disabled?: boolean;
+    executeFn?: (...args: any[]) => void;
+}
+interface ContextMenuItemSelectEvent {
+    action: ContextMenuAction;
+}
+
+declare class ContextmenuComponent {
+    actions: i0.InputSignal<ContextMenuAction[]>;
+    selection: i0.InputSignal<unknown[]>;
+    itemSelect: i0.OutputEmitterRef<ContextMenuItemSelectEvent>;
+    private translate;
+    cdkMenu: i0.Signal<CdkMenu | undefined>;
+    menuItems: i0.Signal<readonly (CdkMenuItem | null)[]>;
+    sortedActions: i0.Signal<ContextMenuAction[]>;
+    constructor();
+    onItemTrigger({ action }: ContextMenuItemSelectEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextmenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextmenuComponent, "yuv-contextmenu", never, { "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; }, { "itemSelect": "itemSelect"; }, never, never, true, never>;
+}
+
+declare class YuvContextMenuTriggerDirective extends CdkContextMenuTrigger {
+    #private;
+    menuTemplateRef: TemplateRef<unknown>;
+    triggerWhen: i0.InputSignal<boolean | null>;
+    constructor();
+    _openOnContextMenu(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<YuvContextMenuTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<YuvContextMenuTriggerDirective, "[yuvContextMenuTrigger]", ["yuvContextMenuTrigger"], { "menuTemplateRef": { "alias": "yuvContextMenuTrigger"; "required": false; }; "triggerWhen": { "alias": "yuvContextMenuTriggerWhen"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ACTION_ICON, AbstractContextAction, ActionsModule, ActionsService, BASE_ACTION, ContextmenuComponent, DeleteAction, DownloadAction, SelectionRange, YuvContextMenuTriggerDirective };
+export type { Action, ActionClass, ActionContext, ActionOptions, ActionSupport, BaseAction, ContextMenuAction, ContextMenuItemSelectEvent };

package/app-bar/index.d.ts

@@ -1 +1,50 @@
-export * from './lib/app-bar.component';
+import * as _angular_core from '@angular/core';
+import { ElementRef, TemplateRef } from '@angular/core';
+
+/**
+ * Application bar for yuuvis Momentum apps.
+ *
+ * Adding a `#appBarSideNav` template to the components body will show a menu icon
+ * that opens its content in a sidenav element.
+ *
+ * Adding a `#appBarActions` template to the component will add its content to
+ * the actions section (at the end of the app bar).
+ *
+ * @example
+ * <yuv-app-bar title="MyMomentumApp">
+ *   <ng-template #appBarSideNav>
+ *     ... content supposed to end up in a sidenav ...
+ *   </ng-template>
+ *   <ng-template #appBarPrimaryActions>
+ *     ... content supposed to end up in the app bars primary actions section ...
+ *   </ng-template>
+ *   <ng-template #appBarActions>
+ *     ... content supposed to end up in the app bars actions section ...
+ *   </ng-template>
+ * </yuv-app-bar>
+ */
+declare class AppBarComponent {
+    dialogElement: ElementRef<HTMLDialogElement> | null;
+    appBarSideNav: TemplateRef<any> | null;
+    appBarActions: TemplateRef<any> | null;
+    appBarPrimaryActions: TemplateRef<any> | null;
+    /**
+     * Menu icon SVG. By default this will be the hamburger menu icon
+     */
+    readonly menuIcon: _angular_core.InputSignal<string>;
+    /**
+     * App title visible in the app beside the menu
+     */
+    readonly appTitle: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Where to route to, when the title is clicked. Defaults to '/'
+     */
+    readonly appTitleRoute: _angular_core.InputSignal<string | undefined>;
+    sidenavVisible: boolean;
+    toggleSideNav(): void;
+    onDialogClick(e: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppBarComponent, "yuv-app-bar", never, { "menuIcon": { "alias": "menuIcon"; "required": false; "isSignal": true; }; "appTitle": { "alias": "appTitle"; "required": false; "isSignal": true; }; "appTitleRoute": { "alias": "appTitleRoute"; "required": false; "isSignal": true; }; }, {}, ["appBarSideNav", "appBarActions", "appBarPrimaryActions"], never, true, never>;
+}
+
+export { AppBarComponent };

package/autocomplete/index.d.ts

@@ -1,3 +1,89 @@
-export * from './lib/autocomplete.module';
-export * from './lib/autocomplete.component';
-export * from './lib/autocomplete.interface';
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, TemplateRef } from '@angular/core';
+import * as _angular_forms from '@angular/forms';
+import { ControlValueAccessor, FormControl } from '@angular/forms';
+import { MatAutocomplete, MatAutocompleteSelectedEvent, MatAutocompleteActivatedEvent } from '@angular/material/autocomplete';
+import { MatChipInputEvent } from '@angular/material/chips';
+import { AbstractMatFormField } from '@yuuvis/client-framework/common';
+
+interface AutocompleteItem<T = unknown> {
+    label: string;
+    value: T;
+}
+
+declare class AutocompleteComponent extends AbstractMatFormField<AutocompleteItem[]> implements ControlValueAccessor, OnInit, OnDestroy {
+    #private;
+    ariaLabel: _angular_core.InputSignal<string>;
+    matAutocomplete: _angular_core.Signal<MatAutocomplete>;
+    /**
+     * Template to be used for rendering selected items in multiselect (multiple="true") mode
+     */
+    chipTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    optionTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    /**
+     * Show a loading spinner
+     */
+    busy: _angular_core.InputSignal<boolean>;
+    /**
+     * Enable multiple values
+     */
+    multiple: _angular_core.InputSignal<boolean>;
+    /**
+     * Force distinct values  (only applicable for multiselect)
+     */
+    distinctValues: _angular_core.InputSignal<boolean>;
+    /**
+     * Add user inputs to the list of values when the user leaves the
+     * control without entering (only applicable for multiselect)
+     */
+    addOnBlur: _angular_core.InputSignal<boolean>;
+    /**
+     * Minimum number of characters entered to trigger suggestions
+     */
+    minLength: _angular_core.InputSignal<number>;
+    /**
+     * Maximum number of items when multiple is true. -1 means no limit.
+     */
+    maxItems: _angular_core.InputSignal<number>;
+    /**
+     * Setting this to `true` will not allow values that are not contained in the suggestions list. The input
+     * will be cleared on blur if no value from the list has been selected. Also values are only emitted when a
+     * list item has been selected (usually every key stroke is changing the form controls value)
+     */
+    forceSelection: _angular_core.InputSignal<boolean>;
+    _acValues: _angular_core.WritableSignal<AutocompleteItem<unknown>[]>;
+    autocompleteValues: _angular_core.InputSignal<AutocompleteItem<unknown>[]>;
+    autocompleteFnc: _angular_core.OutputEmitterRef<string>;
+    acBlur: _angular_core.OutputEmitterRef<void>;
+    chipsInputDisabled: _angular_core.Signal<boolean | null>;
+    chipsControl: FormControl<AutocompleteItem<unknown>[] | null>;
+    inputControl: FormControl<string | AutocompleteItem<unknown>>;
+    ngControl: _angular_forms.NgControl | null;
+    displayFn(i: AutocompleteItem): string;
+    acOptionSelected(event: MatAutocompleteSelectedEvent): void;
+    acOptionActivated(event: MatAutocompleteActivatedEvent): void;
+    acPanelClosed(): void;
+    readonly separatorKeysCodes: number[];
+    add(event: MatChipInputEvent): void;
+    onInputBlur(): void;
+    removeItem(item: AutocompleteItem): void;
+    private _onChange;
+    private _onTouched;
+    writeValue(value: readonly AutocompleteItem[] | AutocompleteItem): void;
+    registerOnChange(fn: (value: readonly AutocompleteItem[] | null) => void): void;
+    registerOnTouched(fn: () => {}): void;
+    setDisabledState?(isDisabled: boolean): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutocompleteComponent, "yuv-autocomplete", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "busy": { "alias": "busy"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "distinctValues": { "alias": "distinctValues"; "required": false; "isSignal": true; }; "addOnBlur": { "alias": "addOnBlur"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxItems": { "alias": "maxItems"; "required": false; "isSignal": true; }; "forceSelection": { "alias": "forceSelection"; "required": false; "isSignal": true; }; "autocompleteValues": { "alias": "autocompleteValues"; "required": false; "isSignal": true; }; }, { "autocompleteFnc": "autocompleteFnc"; "acBlur": "acBlur"; }, ["chipTemplate", "optionTemplate"], never, true, never>;
+}
+
+declare class YuvAutocompleteModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuvAutocompleteModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<YuvAutocompleteModule, never, [typeof AutocompleteComponent], [typeof AutocompleteComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<YuvAutocompleteModule>;
+}
+
+export { AutocompleteComponent, YuvAutocompleteModule };
+export type { AutocompleteItem };

package/breadcrumb/index.d.ts

@@ -1,2 +1,112 @@
-export * from './lib/breadcrumb/breadcrumb.component';
-export * from './lib/models';
+import * as _angular_core from '@angular/core';
+
+/**
+ * A single item in the breadcrumb trail.
+ *
+ * `id` is used as the `@for` track expression and emitted back on click.
+ * `name` is rendered as-is — no truncation, translation, or fallback applied.
+ * Position in the array determines the role: all items except the last are clickable links;
+ * the last item is rendered as non-clickable text representing the current location.
+ */
+interface BreadcrumbItem {
+    /** Unique identifier — emitted via `navigate` output when the item is activated. */
+    id: string;
+    /** Display label shown in the breadcrumb trail. */
+    name: string;
+}
+
+/**
+ * A generic, accessible breadcrumb navigation component.
+ *
+ * Renders a flat list of navigation items where the last item always represents
+ * the current location (non-clickable) and all preceding items are interactive links.
+ * Each link is individually focusable via standard Tab navigation.
+ *
+ * Key behaviors
+ * - Items are rendered left-to-right, separated by a `/` divider
+ * - The **last item** is always the current page — displayed as plain text (no link, no click handler)
+ * - All **preceding items** are rendered as `<a>` links that emit the `navigate` output on click or Enter
+ * - The component performs **no routing** — the parent handles all navigation logic via the emitted `BreadcrumbItem`
+ * - Empty `items` array renders nothing (the host element stays in the DOM but is visually empty)
+ *
+ * Usage
+ *
+ * The parent builds the `BreadcrumbItem[]` and passes it as input. Typically this
+ * array mirrors the object hierarchy the user navigated through (e.g. Case → Phase → Document).
+ *
+ * ```ts
+ * // Parent component
+ * breadcrumbItems: BreadcrumbItem[] = [
+ *   { id: 'case-42',  name: 'Case #42' },      // ← clickable link
+ *   { id: 'phase-3',  name: 'Review' },          // ← clickable link
+ *   { id: 'doc-7',    name: 'Contract.pdf' }     // ← current location (non-clickable)
+ * ];
+ *
+ * onBreadcrumbNavigate(item: BreadcrumbItem): void {
+ *   // item.id is the domain-specific key — use it to navigate
+ *   this.router.navigate(['/objects', item.id]);
+ * }
+ * ```
+ *
+ * ```html
+ * <yuv-breadcrumb
+ *   [items]="breadcrumbItems"
+ *   (navigate)="onBreadcrumbNavigate($event)" />
+ * ```
+ *
+ * Renders visually as:
+ * ```
+ * Case #42  /  Review  /  Contract.pdf
+ * [link]       [link]      [current]
+ * ```
+ */
+declare class YuuvisBreadcrumbComponent {
+    /**
+     * Ordered list of breadcrumb items to display.
+     *
+     * Each `BreadcrumbItem` has `{ id: string; name: string }` — where `id` is a unique key
+     * (typically an object/route ID) and `name` is the display label rendered in the trail.
+     *
+     * Position determines rendering behavior:
+     * - All items except the last → clickable `<a>` links
+     * - Last item → non-clickable text (current location)
+     *
+     * Defaults to an empty array, which renders nothing.
+     *
+     * @example
+     * ```ts
+     * // Case → Document trail
+     * [items]="[
+     *   { id: 'case-42', name: 'Case #42' },
+     *   { id: 'doc-7',   name: 'Invoice.pdf' }
+     * ]"
+     * ```
+     */
+    items: _angular_core.InputSignal<BreadcrumbItem[]>;
+    /**
+     * Emitted when the user activates a clickable breadcrumb item (click or Enter key).
+     *
+     * The emitted value is the full `BreadcrumbItem` object (`{ id, name }`) that was activated.
+     * Never emitted for the last item since it is non-clickable.
+     * The parent is responsible for performing the actual navigation using `item.id`.
+     *
+     * @example
+     * ```ts
+     * onBreadcrumbNavigate(item: BreadcrumbItem): void {
+     *   // item = { id: 'case-42', name: 'Case #42' }
+     *   this.router.navigate(['/objects', item.id]);
+     * }
+     * ```
+     */
+    navigate: _angular_core.OutputEmitterRef<BreadcrumbItem>;
+    /**
+     * Handles click on a breadcrumb link and forwards the item to the parent via `navigate` output.
+     * Called only for non-last items (the template guards against calling this for the current location).
+     */
+    protected onItemClick(item: BreadcrumbItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuuvisBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YuuvisBreadcrumbComponent, "yuv-breadcrumb", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, { "navigate": "navigate"; }, never, never, true, never>;
+}
+
+export { YuuvisBreadcrumbComponent };
+export type { BreadcrumbItem };

package/clipboard/index.d.ts

@@ -1 +1,19 @@
-export * from './lib/clipboard.component';
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+import { TranslateService, ClipboardData } from '@yuuvis/client-core';
+
+declare class ClipboardComponent implements OnInit {
+    #private;
+    translate: TranslateService;
+    clipboardData?: ClipboardData;
+    label?: string;
+    enablePaste: _angular_core.InputSignal<boolean>;
+    bucket: _angular_core.InputSignal<string | undefined>;
+    paste: _angular_core.OutputEmitterRef<void>;
+    clearClipboard(): void;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClipboardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ClipboardComponent, "yuv-clipboard", never, { "enablePaste": { "alias": "enablePaste"; "required": false; "isSignal": true; }; "bucket": { "alias": "bucket"; "required": false; "isSignal": true; }; }, { "paste": "paste"; }, never, never, true, never>;
+}
+
+export { ClipboardComponent };