@yuuvis/client-core 0.6.5

package/lib/service/backend/backend.service.d.ts

@@ -0,0 +1,118 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ConfigService } from '../config/config.service';
+import { HttpDeleteOptions, HttpOptions } from './backend.interface';
+import * as i0 from "@angular/core";
+/**
+ * Service for providing an yuuvis Backend
+ */
+export declare class BackendService {
+    #private;
+    configService: ConfigService;
+    authUsesOpenIdConnect(): boolean;
+    /**
+     * OpenIdConnect authorization headers
+     */
+    getAuthHeaders(): HttpHeaders;
+    /**
+     * Add a new header.
+     * @param key The headers name
+     * @param value The value to be added to the headers. Setting this to null
+     * will remove the header
+     */
+    setHeader(key: string, value: string): void;
+    /**
+     * Wrapped HTTP GET method
+     * @param uri The REST URI to be queried
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The data retrieved from the given endpoint
+     */
+    get(uri: string, base?: string, requestOptions?: HttpOptions): Observable<any>;
+    /**
+     * Wrapped HTTP POST method
+     * @param uri The target REST URI
+     * @param data Data to be 'posted'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target POST endpoint
+     */
+    post(uri: string, data?: any, base?: string, requestOptions?: HttpOptions): Observable<any>;
+    /**
+     * Performs a multipart form data POST request.
+     * @param uri The target REST URI
+     * @param formData FormData to be 'posted'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target POST endpoint
+     */
+    postMultiPart(uri: string, formData: FormData, base?: string, requestOptions?: HttpOptions): Observable<any>;
+    /**
+     * Wrapped HTTP PATCH method
+     * @param uri The target REST URI
+     * @param data Data to be 'patched'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target PATCH endpoint
+     */
+    patch(uri: string, data?: any, base?: string, requestOptions?: HttpOptions): Observable<any>;
+    /**
+     * Wrapped HTTP PUT method
+     * @param uri The target REST URI
+     * @param data Data to be 'posted'
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target PUT endpoint
+     */
+    put(uri: string, data?: any, base?: string, requestOptions?: HttpOptions): Observable<any>;
+    /**
+     * Wrapped HTTP DELETE method
+     * @param uri The target REST URI
+     * @param base The Base URI (backend service) to be used
+     * @param requestOptions Additional request options
+     * @returns The return value of the target DELETE endpoint
+     */
+    delete(uri: string, base?: string, requestOptions?: HttpDeleteOptions): Observable<any>;
+    /**
+     * @ignore
+     * Cache for small requests like icons and configs
+     *
+     * @param string uri
+     * @returns Observable<any>
+     */
+    getViaCache(uri: string): Observable<any>;
+    /**
+     * @ignore
+     * Temporary Cache for multiple identical requests
+     *
+     * @param string id
+     * @param Function request
+     * @returns Observable<any>
+     */
+    getViaTempCache(id: string, request?: () => Observable<object>): Observable<any>;
+    download(uri: string, filename?: string): void;
+    /**
+     * Gets the base URI for an API endpoint
+     * @param api The API to get the base URI for. Leaving this blank will return
+     * base URI for the web API
+     * @param origin The flag to include location origin
+     * @returns Base URI for the given API.
+     */
+    getApiBase(api?: string, origin?: boolean): string;
+    /**
+     * @ignore
+     */
+    getHttpOptions(requestOptions?: HttpOptions): HttpOptions;
+    /**
+     * Batch service
+     */
+    batch(requests: {
+        method?: string;
+        uri: string;
+        body?: any;
+        base?: string;
+        requestOptions?: HttpOptions;
+    }[]): Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackendService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BackendService>;
+}

package/lib/service/bpm/bpm.interface.d.ts

@@ -0,0 +1,86 @@
+export declare const ProcessAction: {
+    complete: string;
+    claim: string;
+    delegate: string;
+    resolve: string;
+    save: string;
+};
+export interface Process {
+    id: string;
+    attachments: string[];
+    businessKey: string;
+    deleteReason: string;
+    durationInMillis: number;
+    endActivityId: string;
+    endTime: Date;
+    initiator: ProcessUser;
+    name: string;
+    processDefinition: {
+        description: string;
+        id: string;
+        idPrefix: string;
+        name: string;
+    };
+    startActivityId: string;
+    startTime: Date;
+    startUserId: string;
+    suspended?: boolean;
+    variables: ProcessVariable[];
+}
+export interface ProcessCreatePayload extends ProcessPostPayload {
+    processDefinitionKey: string;
+    name?: string;
+    businessKey?: string;
+    returnVariables?: boolean;
+}
+export interface ProcessPostPayload {
+    variables?: ProcessVariable[];
+    attachments?: string[];
+    subject?: string;
+}
+export interface ProcessVariable {
+    name: string;
+    type?: string;
+    value: any;
+    readonly?: boolean;
+    scope?: string;
+}
+/**
+ * Tasks are basically activities defined by a process.
+ * Processes may contain several tasks.
+ */
+export interface InboxTask {
+    id: string;
+    processInstanceId: string;
+    assignee: ProcessUser;
+    claimTime: Date;
+    createTime: Date;
+    dueDate: Date;
+    description: string;
+    delegationState?: string;
+    formKey: string;
+    initiator: ProcessUser;
+    name: string;
+    owner: ProcessUser;
+    parentTaskId: string;
+    processDefinition: {
+        id: string;
+        idPrefix: string;
+    };
+    suspended: false;
+    variables: ProcessVariable[];
+    resolvedValues?: {
+        [id: string]: string;
+    };
+    attachments: string[];
+}
+export interface ProcessUser {
+    id: string;
+    title: string;
+}
+export interface FetchTaskOptions {
+    businessKey?: string;
+    includeProcessVar?: boolean;
+    isCompleted?: boolean;
+    processDefinitionKey?: string;
+}

package/lib/service/bpm/bpm.service.d.ts

@@ -0,0 +1,19 @@
+import { FetchTaskOptions, Process, ProcessCreatePayload, ProcessPostPayload } from './bpm.interface';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class BpmService {
+    #private;
+    startProcess(payload: ProcessCreatePayload): Observable<any>;
+    /**
+     * Finsihes a task.
+     * @param taskId ID of the taks to finish
+     * @param payload Data to be send with the complete request (may contain attachments, a new subject or variables)
+     */
+    completeTask(taskId: string, payload?: ProcessPostPayload): Observable<any>;
+    updateTask(taskId: string, payload?: ProcessPostPayload): Observable<any>;
+    getProcessPoll(): Observable<any>;
+    getProcessInstance(processDefinitionKey: string, options?: FetchTaskOptions): Observable<Process>;
+    deleteProcess(processInstanceId: string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BpmService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BpmService>;
+}

package/lib/service/cache/app-cache.service.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service for saving or caching data on the users device. It uses the most efficient storage
+ * available  (IndexDB, localstorage, ...) on the device. Depending on the type of storage used,
+ * its limitations apply.
+ */
+export declare class AppCacheService {
+    #private;
+    setItem(key: string, value: any): Observable<boolean>;
+    getItem(key: string): Observable<any>;
+    removeItem(key: string): Observable<boolean>;
+    clear(filter?: (key: any) => boolean): Observable<boolean>;
+    getStorageKeys(): Observable<any>;
+    setStorage(options: any): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppCacheService>;
+}

package/lib/service/catalog/catalog.interface.d.ts

@@ -0,0 +1,12 @@
+export interface BaseCatalog {
+    entries: CatalogEntry[];
+    readonly?: boolean;
+}
+export interface Catalog extends BaseCatalog {
+    qname: string;
+    tenant?: string;
+}
+export interface CatalogEntry {
+    name: string;
+    disabled?: boolean;
+}

package/lib/service/catalog/catalog.service.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class CatalogService {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogService>;
+}

package/lib/service/clipboard/clipboard.interface.d.ts

@@ -0,0 +1,11 @@
+import { DmsObject } from "../../model/dms-object.model";
+export interface ClipboardStore {
+    buckets?: Record<string, ClipboardData>;
+    main?: ClipboardData;
+}
+export interface ClipboardData {
+    mode?: ClipboardDataMode;
+    files?: File[];
+    objects?: DmsObject[];
+}
+export type ClipboardDataMode = 'copy' | 'cut';

package/lib/service/clipboard/clipboard.service.d.ts

@@ -0,0 +1,23 @@
+import { Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DmsObject } from '../../model/dms-object.model';
+import { ClipboardData, ClipboardDataMode } from './clipboard.interface';
+import * as i0 from "@angular/core";
+export declare class ClipboardService {
+    #private;
+    clipboard(bucket?: string): Signal<ClipboardData | undefined>;
+    clipboard$(bucket?: string): Observable<ClipboardData | undefined>;
+    paste$(bucket?: string): Observable<ClipboardData>;
+    getClipboardData(bucket?: string): ClipboardData | undefined;
+    /**
+     * Add objects to the clipboard
+     * @param bucket Buckets are ways to separate data from the global scope.
+     * If you have an app that would like to have a separate section in the clipboard
+     * you'll use a unique bucket to store your stuff. When observing chages to the
+     * clipboard you couls as well provide the bucket and you will only get
+     */
+    addObjects(objects: DmsObject[], mode: ClipboardDataMode, bucket?: string): void;
+    clear(bucket?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
+}

package/lib/service/config/config.interface.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Interface for the applications main config file
+ * @ignore
+ */
+export interface YuvConfig {
+    core: {
+        languages: YuvConfigLanguages[];
+        logging?: {
+            level: 'debug' | 'error' | 'warn' | 'info';
+        };
+        permissions?: {
+            retentionManagerRole?: string;
+            advancedUserRole?: string;
+            manageSettingsRole?: string;
+        };
+    };
+    location?: {
+        hostname?: string;
+        port?: number;
+    };
+}
+/**
+ * interface providing localization of application
+ */
+export interface YuvConfigLanguages {
+    iso: string;
+    label: string;
+    dir?: Direction;
+    fallback?: boolean;
+}
+export declare enum Direction {
+    LTR = "ltr",
+    RTL = "rtl"
+}

package/lib/service/config/config.service.d.ts

@@ -0,0 +1,45 @@
+import { HttpHeaders } from '@angular/common/http';
+import { YuvConfig, YuvConfigLanguages } from './config.interface';
+import * as i0 from "@angular/core";
+/**
+ * Load and provide configuration for hole apllication while application is inizialized.
+ */
+export declare class ConfigService {
+    private translate;
+    private oidcService;
+    static GLOBAL_RESOURCES: string;
+    static PARSER(c: any): any;
+    static GLOBAL_MAIN_CONFIG(prefix?: 'system' | 'admin' | ''): string;
+    static GLOBAL_MAIN_CONFIG_LANG(iso?: string, prefix?: 'system' | 'admin' | ''): string;
+    static GLOBAL_RESOURCES_PATH(section?: string, prefix?: 'system' | 'admin' | ''): string;
+    get oidc(): import("@yuuvis/client-core").OpenIdConfig | undefined;
+    private cfg?;
+    /**
+     * Set during app init (see CoreInit)
+     * @ignore
+     */
+    set(cfg: YuvConfig): void;
+    get(configKey: string): any;
+    extendTranslations(translations: any, lang?: string): void;
+    extendConfig(configs: YuvConfig[]): void;
+    private _mergeConfigs;
+    authUsesOpenIdConnect(): boolean;
+    /**
+     * OpenIdConnect authorization headers
+     */
+    getAuthHeaders(authorization?: boolean): HttpHeaders;
+    /**
+     * Getter for the available client locales
+     * @returns available client locales
+     */
+    getClientLocales(): YuvConfigLanguages[];
+    getApiBase(api?: string, origin?: boolean): string;
+    /**
+     * Get the default client locale
+     * @returns ISO string of the locale
+     */
+    getDefaultClientLocale(): string;
+    private _getCoreConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
+}

package/lib/service/config/core-config.d.ts

@@ -0,0 +1,14 @@
+import { OpenIdConfig } from '../backend/backend.interface';
+import { YuvConfig } from './config.interface';
+/**
+ * @ignore
+ */
+export declare class CoreConfig {
+    main?: YuvConfig | string[];
+    translations?: string[];
+    environment?: {
+        production: boolean;
+    };
+    oidc?: OpenIdConfig;
+    constructor(__config: CoreConfig);
+}

package/lib/service/config/core-config.tokens.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import { CoreConfig } from './core-config';
+/**
+ * @ignore
+ */
+export declare const CUSTOM_CONFIG: InjectionToken<CoreConfig>;
+export declare const CORE_CONFIG: InjectionToken<CoreConfig>;

package/lib/service/connection/connection.service.d.ts

@@ -0,0 +1,25 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * This service is used for connecting and initializing in the client
+ */
+export declare class ConnectionService {
+    private currentState;
+    private connectionStateSource;
+    connection$: Observable<ConnectionState>;
+    /**
+     * @ignore
+     */
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConnectionService>;
+}
+/**
+ * Check a connection state of a client
+ */
+export interface ConnectionState {
+    /**
+     * whether or not the application is online.
+     */
+    isOnline: boolean;
+}

package/lib/service/connection/offline.interceptor.d.ts

@@ -0,0 +1,15 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ConnectionService } from './connection.service';
+import * as i0 from "@angular/core";
+/**
+ *  Http Offline interceptor trys to serving offline content for method/url
+ */
+export declare class OfflineInterceptor implements HttpInterceptor {
+    private connectionService;
+    offline: boolean;
+    constructor(connectionService: ConnectionService);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OfflineInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OfflineInterceptor>;
+}

package/lib/service/core-init/core-init.service.d.ts

@@ -0,0 +1,11 @@
+import { HttpClient } from '@angular/common/http';
+import { AuthService } from '../auth/auth.service';
+import { YuvConfig } from '../config/config.interface';
+import { ConfigService } from '../config/config.service';
+import { CoreConfig } from '../config/core-config';
+import { DeviceService } from '../device/device.service';
+import { Logger } from '../logger/logger';
+/**
+ * Providing functions,that are are injected at application startup and executed during app initialization.
+ */
+export declare function init_moduleFnc(coreConfig: CoreConfig, deviceService: DeviceService, logger: Logger, http: HttpClient, configService: ConfigService, authService: AuthService): () => import("rxjs").Observable<YuvConfig[]> | import("rxjs").Observable<boolean | import("@yuuvis/client-core").YuvUser>;

package/lib/service/core-init/missing-translation-handler.d.ts

@@ -0,0 +1,8 @@
+import { MissingTranslationHandler, MissingTranslationHandlerParams } from '@ngx-translate/core';
+/**
+ * Handles missing translations
+ * @ignore
+ */
+export declare class EoxMissingTranslationHandler implements MissingTranslationHandler {
+    handle(params: MissingTranslationHandlerParams): string;
+}

package/lib/service/core-init/translate-json-loader.d.ts

@@ -0,0 +1,20 @@
+import { HttpClient } from '@angular/common/http';
+import { TranslateLoader } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { CoreConfig } from '../config/core-config';
+/**
+ * Loader that fetches translations based on the configured locations
+ * @ignore
+ */
+export declare class EoxTranslateJsonLoader implements TranslateLoader {
+    http: HttpClient;
+    config: CoreConfig;
+    constructor(http: HttpClient, config: CoreConfig);
+    /**
+     *
+     * @param string lang
+     * @returns Observable<Object>
+     */
+    getTranslation(lang: string): Observable<Object>;
+    private loadTranslationFile;
+}

package/lib/service/device/device.interface.d.ts

@@ -0,0 +1,15 @@
+export declare enum DeviceScreenOrientation {
+    PORTRAIT = "portrait",
+    LANDSCAPE = "landscape"
+}
+export interface DeviceScreen {
+    size: ScreenSize;
+    orientation: DeviceScreenOrientation;
+    width: number;
+    height: number;
+}
+export interface DeviceScreenBounds {
+    width: number;
+    height: number;
+}
+export type ScreenSize = 's' | 'm' | 'l' | 'xl';

package/lib/service/device/device.service.d.ts

@@ -0,0 +1,54 @@
+import { DeviceInfo } from 'ngx-device-detector';
+import { Observable } from 'rxjs';
+import { DeviceScreen } from './device.interface';
+import * as i0 from "@angular/core";
+/**
+ * This service is used to adapt styles and designs of the client to
+ * different devices and screen sizes.
+ *
+ * Using `screenChange$` observable you are able to monitor changes to
+ * the screen size and act upon it.
+ *
+ * This service will also adds attributes to the body tag that reflect the
+ * current screen/device state. This way you can apply secific styles in your
+ * css files for different screen resolutions and orientations.
+ *
+ * Attributes applied to the body tag are:
+ *
+ * - `data-screen` - [s, m, l, xl] - for different screen sizes
+ * (s: for mobile phone like screen sizes, m: for tablet like screen
+ * sizes, 'l': for desktop like screen sizes, 'xl': for screen sizes exceeding
+ * the desktop screen size).
+ *
+ * - `data-orientation` - [portrait, landscape] - for the current screen orientation
+ *
+ * - `data-touch-enabled` - [true] - if the device has touch capabilities (won't be added if the device doesn't have touch capabilities)
+ *
+ * ```html
+ * <body data-screen-size="s" data-screen-orientation="portrait" data-touch-enabled="true">
+ * ...
+ * </body>
+ * ```
+ */
+export declare class DeviceService {
+    #private;
+    screenChange$: Observable<DeviceScreen>;
+    /**
+     * if the device is a mobile device (android / iPhone / windows-phone etc)
+     */
+    isMobile: boolean;
+    /**
+     *  if the device us a tablet (iPad etc)
+     */
+    isTablet: boolean;
+    /**
+     * if the app is running on a Desktop browser
+     */
+    isDesktop: boolean;
+    info?: DeviceInfo;
+    isTouchEnabled: boolean;
+    constructor();
+    init(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceService>;
+}