@yuuvis/client-framework 0.6.5

package/object-form/lib/form-scripting.api.interface.d.ts

@@ -0,0 +1,131 @@
+import { HttpOptions, YuvEvent, YuvUser } from '@yuuvis/client-core';
+import { Observable } from 'rxjs';
+import { ObjectFormComponent } from './object-form.component';
+import { ObjectFormModelChange } from './object-form.interface';
+/**
+ * Providing a plugin service and injected into form scripts
+ */
+export interface FormScriptingAPI {
+    /**
+     * Register a new form scripting element extension
+     */
+    elementExtensions: {
+        register(extensions: FormScriptingElementExtension[]): void;
+    };
+    /**
+     * Listen to a certain type of yuuvis event ({@link YuvEventType})
+     *
+     */
+    events: {
+        yuuvisEventType: any;
+        on(type: string): Observable<YuvEvent>;
+        /**
+         * Trigger a certain type of yuuvis event ({@link YuvEventType})
+         * @param type Key of the event to be triggered
+         * @param data Some data to attach to the event
+         */
+        trigger(type: string, data?: any): void;
+    };
+    /**
+     * Get the user that is currently logged in
+     */
+    session: {
+        getUser(): YuvUser;
+        user: {
+            get: () => YuvUser;
+            hasRole: (role: string) => boolean;
+        };
+    };
+    /**
+     * Execute a requests against yuuvis backend
+     */
+    http: {
+        /**
+         * Execute a GET request against yuuvis backend
+         * @param uri URI the request should be sent to
+         * @param base URI part of the service this request belongs to
+         * @param options additional HttpOptions
+         */
+        get(uri: string, base?: string, options?: HttpOptions): any;
+        /**
+         * Execute a POST request against yuuvis backend
+         * @param uri URI the request should be sent to
+         * @param data Data to be send along with the request
+         * @param base URI part of the service this request belongs to
+         * @param options additional HttpOptions
+         */
+        post(uri: string, data: any, base?: string, options?: HttpOptions): any;
+        /**
+         * Execute a DELETE request against yuuvis backend
+         * @param uri URI the request should be sent to
+         * @param base URI part of the service this request belongs to
+         * @param options additional HttpOptions
+         */
+        del(uri: string, base?: string, options?: HttpOptions): any;
+        /**
+         * Execute a PUT request against yuuvis backend
+         * @param uri URI the request should be sent to
+         * @param data Data to be send along with the request
+         * @param base URI part of the service this request belongs to
+         * @param options additional HttpOptions
+         */
+        put(uri: string, data: any, base?: string, options?: HttpOptions): any;
+    };
+    /**
+     * Utilities
+     */
+    form: {
+        activeForms: Map<string, ObjectFormComponent>;
+        getValue(formControlName: string): any;
+        setValue(formControlName: string, newValue: any): void;
+        /**
+         * Execute a change of form model
+         * @param formControlName form control unique name | identifier
+         * @param change object that contains name of parameter that should be changed ('value', 'required', ...) and newValue
+         */
+        modelChange(formControlName: string, change: ObjectFormModelChange): void;
+    };
+    storage: {
+        getItem: (key: string) => any;
+        setItem: (key: string, value: unknown) => any;
+    };
+    notifier: {
+        /**
+         * Trigger a SUCCESS notification
+         * @param text Message to be 'toasted'
+         * @param title Title
+         */
+        success(text: string, title: string): void;
+        /**
+         * Trigger a ERROR notification
+         * @param text Message to be 'toasted'
+         * @param title Title
+         */
+        error(text: string, title: string): void;
+        /**
+         * Trigger a INFO notification
+         * @param text Message to be 'toasted'
+         * @param title Title
+         */
+        info(text: string, title: string): void;
+        /**
+         * Trigger a WARNING notification
+         * @param text Message to be 'toasted'
+         * @param title Title
+         */
+        warning(text: string, title: string): void;
+    };
+    /**
+     * Utilities
+     */
+    util: {
+        translate: (key: string, data?: any) => string;
+    };
+}
+export interface FormScriptingElementExtension {
+    id: string;
+    icon?: string;
+    label?: string;
+    propertyName: string;
+    callback: () => void;
+}

package/object-form/lib/form-scripting.service.d.ts

@@ -0,0 +1,30 @@
+import { DmsObject, HttpOptions, YuvUser } from '@yuuvis/client-core';
+import { FormScriptingAPI, FormScriptingElementExtension } from './form-scripting.api.interface';
+import { ObjectFormComponent } from './object-form.component';
+import * as i0 from "@angular/core";
+export declare class FormScriptingApiService {
+    #private;
+    static EVENT_MODEL_CHANGED: string;
+    elementExtensions: import("@angular/core").WritableSignal<Record<string, FormScriptingElementExtension>>;
+    formId?: string;
+    get api(): FormScriptingAPI;
+    registerActiveForm(component: ObjectFormComponent): any;
+    unregisterActiveForm(component: ObjectFormComponent): any;
+    getApi(): FormScriptingAPI;
+    get(uri: string, base?: string, options?: HttpOptions): Promise<any>;
+    put(uri: string, data: Record<string, unknown>, base?: string, options?: HttpOptions): Promise<any>;
+    post(uri: string, data: Record<string, unknown>, base?: string, options?: HttpOptions): Promise<any>;
+    del(uri: string, base?: string, options?: HttpOptions): Promise<any>;
+    getCurrentUser(): YuvUser;
+    getDmsObject(id: string, version: number): Promise<DmsObject>;
+    /**
+     * fetches dms objects from the server that match the given params
+     *
+     * @param fields - the fields to match. example: {name: 'max', plz: '47111}
+     * @param type - the target object type
+     */
+    getResult(fields: Record<string, unknown>, type?: string): Promise<DmsObject[]>;
+    encodeFileName(filename: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormScriptingApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormScriptingApiService>;
+}

package/object-form/lib/object-form-element/object-form-element.component.d.ts

@@ -0,0 +1,22 @@
+import { Type } from '@angular/core';
+import { ObjectFormControlWrapper } from '../object-form.interface';
+import { ObjectFormElementExtension } from '../object-form-extension.interface';
+import { FormScriptingElementExtensionComponent } from '../object-form-script/form-scripting-element-extension/form-scripting-element-extension.component';
+import { FormScriptingElementExtension } from '../form-scripting.api.interface';
+import * as i0 from "@angular/core";
+export declare class ObjectFormElementComponent {
+    #private;
+    createForm: import("@angular/core").WritableSignal<boolean>;
+    formControlName?: string;
+    formElementRef: any;
+    errors?: string[];
+    extensionComponents: Type<ObjectFormElementExtension>[];
+    scriptingExtensions: import("@angular/core").Signal<FormScriptingElementExtension[]>;
+    scriptExtensionCmp: typeof FormScriptingElementExtensionComponent;
+    situation: import("@angular/core").InputSignal<string | undefined>;
+    element: import("@angular/core").InputSignal<ObjectFormControlWrapper | undefined>;
+    get extensionComponentInput(): Record<string, unknown>;
+    onDataMetaChange(data: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectFormElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectFormElementComponent, "yuv-object-form-element", never, { "situation": { "alias": "situation"; "required": false; "isSignal": true; }; "element": { "alias": "element"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/object-form/lib/object-form-extension.interface.d.ts

@@ -0,0 +1,22 @@
+import { Type } from '@angular/core';
+import { FormScriptingAPI } from './form-scripting.api.interface';
+import * as i0 from "@angular/core";
+export interface IObjectFormElementExtension {
+    property: string;
+    cmp: Type<ObjectFormElementExtension>;
+}
+export interface IObjectFormElementExtensionComponentInput {
+    formControlName: string;
+}
+/**
+ * Class to extend by form element extensions.
+ */
+export declare abstract class ObjectFormElementExtension {
+    #private;
+    input: import("@angular/core").InputSignal<IObjectFormElementExtensionComponentInput>;
+    protected getApi(): FormScriptingAPI;
+    protected getCurrentValue(): unknown;
+    setValue(value: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectFormElementExtension, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectFormElementExtension, "ng-component", never, { "input": { "alias": "input"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/object-form/lib/object-form-group/object-form-group.component.d.ts

@@ -0,0 +1,22 @@
+import { AbstractControl } from '@angular/forms';
+import { Situation } from '@yuuvis/client-core';
+import { ObjectFormControlWrapper, YuvFormGroup, YuvFormGroupWrapper } from '../object-form.interface';
+import { ObjectFormGroup } from '../object-form.model';
+import * as i0 from "@angular/core";
+export declare class ObjectFormGroupComponent {
+    #private;
+    private types;
+    groupType?: string;
+    isCore: boolean;
+    isData: boolean;
+    situation: Situation;
+    group: import("@angular/core").InputSignal<ObjectFormGroup | undefined>;
+    noGroupLabels: import("@angular/core").InputSignal<boolean | undefined>;
+    getHeaderStyleClass(ctrl: AbstractControl): string;
+    getChildControl(ctrl: AbstractControl): ObjectFormGroup;
+    getObjectFormGroup(control: any): YuvFormGroup | undefined;
+    getObjectFormControlWrapper(control: any): YuvFormGroupWrapper | undefined;
+    getElement(control: any): ObjectFormControlWrapper;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectFormGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectFormGroupComponent, "yuv-object-form-group", never, { "situation": { "alias": "situation"; "required": false; }; "group": { "alias": "group"; "required": false; "isSignal": true; }; "noGroupLabels": { "alias": "noGroupLabels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/object-form/lib/object-form-script/form-scripting-element-extension/form-scripting-element-extension.component.d.ts

@@ -0,0 +1,10 @@
+import { FormScriptingElementExtension } from '../../form-scripting.api.interface';
+import { ObjectFormElementExtension } from '../../object-form-extension.interface';
+import * as i0 from "@angular/core";
+export declare class FormScriptingElementExtensionComponent extends ObjectFormElementExtension {
+    ext: import("@angular/core").InputSignal<FormScriptingElementExtension | undefined>;
+    defaultIcon: string;
+    run(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormScriptingElementExtensionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormScriptingElementExtensionComponent, "yuv-form-scripting-element-extension", never, { "ext": { "alias": "ext"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/object-form/lib/object-form-script/object-form-script.service.d.ts

@@ -0,0 +1,45 @@
+import { BackendService, Logger } from '@yuuvis/client-core';
+import { ObjectFormScriptingScope } from './object-form-scripting-scope';
+import * as i0 from "@angular/core";
+/**
+ * @ignore
+ */
+export declare class ObjectFormScriptService {
+    private logger;
+    private backend;
+    constructor(logger: Logger, backend: BackendService);
+    /**
+     * Run a form script.
+     * @param scope - the current scripting scope
+     * @param script - the script to be executed
+     * @param [scriptName] - the scripts name
+     */
+    runFormScript(scope: ObjectFormScriptingScope, script: any, scriptName?: string): void;
+    /**
+     * Define form script function, appending source url as comment.
+     * Enables debugging using browser debugging tools (Chrome+Firefox)
+     * @see: https://developer.mozilla.org/en-US/docs/Tools/Debugger/How_to/Debug_eval_sources
+     *
+     * @param name - the name of the script
+     * @param script - script to be wrapped in a function
+     * @returns the function
+     */
+    private defineFunction;
+    /**
+     * If the script contains global script, this function will import and run them
+     * before running the actual script.
+     *
+     * @param scope - the current scripting scope
+     * @param formScriptReturn - the return value of the actual form script
+     */
+    private importGlobalScriptsAndCallInit;
+    /**
+     * Fetch global scripts.
+     * @param name - the name of the global script
+     * @param scope - the current scripting scope
+     * @returns
+     */
+    private resolveGlobalScript;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectFormScriptService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectFormScriptService>;
+}

package/object-form/lib/object-form-script/object-form-scripting-scope.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @ignore
+ * This class will be injected as scope into form scripts.
+ */
+export declare class ObjectFormScriptingScope {
+    situation: string;
+    private onScriptingModelChange;
+    api: any;
+    private isTableRowScope?;
+    model: any;
+    data: any;
+    objectId?: string;
+    actions: any;
+    objects: any[];
+    context: {
+        id: string;
+        title: string;
+        objectTypeId: string;
+    };
+    /**
+     * Constructor
+     * @param situation - Current form model situation (could be CREATE, SEARCH or EDIT)
+     * @param onScriptingModelChange - callback function to be called when the scripting model changed
+     * Be aware to provide an instance method as callback for the scripting scope.
+     * @see: https://blog.johnnyreilly.com/2014/04/typescript-instance-methods.html
+     *
+     * @param api - Plugin API reference
+     * @param isTableRowScope - set this to true if the current scripting scope is created for a
+     * row editing form from a table element. It will then provide the right parameters for the scripting functions
+     */
+    constructor(situation: string, onScriptingModelChange: Function, api: any, isTableRowScope?: boolean | undefined);
+    /**
+     * Sets the internal model and wraps every model element with an observer to be
+     * able to track their changes from within a form script
+     * @param model
+     */
+    setModel(model: any): void;
+    /**
+     * Returns the observed model. Used for row editing forms of table elements that
+     * create their own scripting scope in context of their parent form.
+     * @returns the observed scripting scope model
+     */
+    getModel(): any;
+    /**
+     * Called by the object form when the form model changes.
+     * @param change - object with key equals name of the element
+     * that changes and value of the new value
+     */
+    modelChanged(change: any): void;
+}

package/object-form/lib/object-form-translate.service.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+/**
+ * Providing an error message when a translation string for an object wasn't found
+ */
+export declare class ObjectFormTranslateService {
+    private translate;
+    /**
+     * Set the error label if a translation for this string wasn't provided
+     * @param error - error message about a missed translation key
+     * @param params
+     */
+    getErrorLabel(error: string, params?: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectFormTranslateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectFormTranslateService>;
+}

package/object-form/lib/object-form.component.d.ts

@@ -0,0 +1,60 @@
+import { AfterViewInit, OnDestroy } from '@angular/core';
+import { IObjectFormElementExtension } from './object-form-extension.interface';
+import { FormStatusChangedEvent, ObjectFormOptions } from './object-form.interface';
+import { ObjectFormGroup } from './object-form.model';
+import * as i0 from "@angular/core";
+export declare class ObjectFormComponent implements OnDestroy, AfterViewInit {
+    #private;
+    gCount: number;
+    id: string;
+    fo?: ObjectFormOptions;
+    formOptions: import("@angular/core").InputSignal<ObjectFormOptions | undefined>;
+    inert: import("@angular/core").InputSignal<boolean | undefined>;
+    elementExtensions: import("@angular/core").InputSignal<IObjectFormElementExtension[]>;
+    /**
+     * There are special scenarios where forms are within a form themselves.
+     * Setting this property to true, will handle the current form in a
+     * slightly different way when it comes to form scripting.
+     */
+    isInnerTableForm: import("@angular/core").InputSignal<boolean | undefined>;
+    /**
+     * triggered when the forms state has been changed
+     */
+    statusChanged: import("@angular/core").OutputEmitterRef<FormStatusChangedEvent>;
+    /**
+     * handler to be executed after the form has been set up
+     */
+    onFormReady: import("@angular/core").OutputEmitterRef<void>;
+    form?: ObjectFormGroup;
+    formData: any;
+    constructor();
+    focusForm(): void;
+    getGroup(id: string): ObjectFormGroup;
+    setFormData(data: Record<string, unknown>): void;
+    patchValue(data: Record<string, unknown>): void;
+    /**
+     * Extracts the values from the form model. Each form value is represented by one
+     * property on the result object holding the fields value. The keys (properties) are the `name`
+     * properties of the form element.
+     *
+     * How values are extracted is influenced by the forms situation.
+     *
+     * @return object of key value pairs
+     */
+    getFormData(): {};
+    getFormElements(): any;
+    setFormPristine(): void;
+    resetForm(): void;
+    /**
+     * Returns the observed model that was passed to the current form script running. If there is
+     * no form script, this method will return NULL.
+     * @returns
+     */
+    getObservedScriptModel(): any;
+    initValidators(form: any): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    private unsubscribeAll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectFormComponent, "yuv-object-form", never, { "formOptions": { "alias": "formOptions"; "required": false; "isSignal": true; }; "inert": { "alias": "inert"; "required": false; "isSignal": true; }; "elementExtensions": { "alias": "elementExtensions"; "required": false; "isSignal": true; }; "isInnerTableForm": { "alias": "isInnerTableForm"; "required": false; "isSignal": true; }; }, { "statusChanged": "statusChanged"; "onFormReady": "onFormReady"; }, never, never, true, never>;
+}

package/object-form/lib/object-form.interface.d.ts

@@ -0,0 +1,113 @@
+import { UntypedFormGroup } from '@angular/forms';
+import { ObjectFormGroup } from './object-form.model';
+export interface IObjectForm {
+    getFormData(): void;
+    setFormPristine(): void;
+    resetForm(): void;
+}
+/**
+ * @ignore
+ */
+export type ObjectFormModel = ObjectFormGroup | ObjectFormControlWrapper;
+/**
+ * Interface for providing components, that render an model based form.
+ */
+export interface ObjectFormOptions {
+    /**
+     * The form model holding all groups and elements
+     */
+    formModel: any;
+    /**
+     * Data to be merged with the forms model. Usually this will be an
+     * object of property value pairs where the properties name equals the name of
+     * the form element. For search forms (form situation 'SEARCH') data is supposed
+     * to be an array of SearchFilter objects, because search forms may support
+     * range searches in some cases.
+     */
+    data: Record<string, unknown>;
+    objectId?: string;
+    /**
+     * whether or not to disable the complete form
+     */
+    disabled?: boolean;
+    /**
+     * in context of BPM forms, form scripts will also provide access to the actions
+     * of a work item. This object is supposed to contain properties in a key value manner,
+     * where key is the actions code and value is the WorkItemAction itself.
+     */
+    actions?: any;
+    /**
+     * object form may also provide a collection of objects to be passed to the
+     * form script (e.g. BPM forms provide data from attached dms objects)
+     */
+    objects?: any[];
+    context?: {
+        id: string;
+        title: string;
+        objectTypeId: string;
+    };
+}
+/**
+ * Wrapper for a rendering a from group
+ */
+export interface YuvFormGroupWrapper {
+    /**
+     * form control situation (CREATE, EDIT, SEARCH)
+     */
+    situation: string;
+    /**
+     * the name of the wrapped form control
+     */
+    controlName: string;
+}
+/**
+ * @ignore
+ * Extend angulars default FormGroup for implementation of a form group wrapping
+ * a form control.
+ */
+export declare class ObjectFormControlWrapper extends UntypedFormGroup {
+    _eoFormControlWrapper?: YuvFormGroupWrapper;
+}
+/**
+ * Input data for a form group
+ */
+export interface YuvFormGroup {
+    /**
+     * the label for the form group
+     */
+    label?: string;
+    /**
+     * object holding properties defining layout properties of the group
+     */
+    layout: any;
+    /**
+     * type of group indicating if the form is a stack, a fieldset or a simple group
+     */
+    type: string;
+}
+/**
+ * event data emitted by the statusChanged callback
+ */
+export interface FormStatusChangedEvent {
+    /**
+     * flag indicating whether or not the form is invalid
+     *
+     */
+    invalid: boolean;
+    /**
+     * flag indicating whether or not the form has been edited
+     */
+    dirty: boolean;
+    /**
+     * flag indicating whether or not the forms indexdata has been changed
+     */
+    indexdataChanged: boolean;
+    /**
+     * the extracted data from the form
+     */
+    data?: any;
+}
+export type ObjectFormModelChange = {
+    name: 'value' | 'required' | 'readonly' | 'error' | 'onrowedit' | 'onchange';
+    newValue: any;
+};

package/object-form/lib/object-form.model.d.ts

@@ -0,0 +1,18 @@
+import { FormControl, FormGroup } from '@angular/forms';
+import { YuvFormGroup } from './object-form.interface';
+/**
+ * @ignore
+ * Extension of the default angular form group,
+ */
+export declare class ObjectFormGroup extends FormGroup {
+    _eoFormGroup?: YuvFormGroup;
+}
+/**
+ * @ignore
+ * Extension of the default angular form control,
+ */
+export declare class ObjectFormControl extends FormControl {
+    private __eoFormElement;
+    set _eoFormElement(v: any);
+    get _eoFormElement(): any;
+}

package/object-form/lib/object-form.service.d.ts

@@ -0,0 +1,39 @@
+import { Type } from '@angular/core';
+import { IObjectFormElementExtension, ObjectFormElementExtension } from './object-form-extension.interface';
+import { ObjectFormControlWrapper } from './object-form.interface';
+import { ObjectFormGroup } from './object-form.model';
+import * as i0 from "@angular/core";
+/**
+ * @ignore
+ */
+export declare class ObjectFormService {
+    #private;
+    setElementExtensions(formExtensions: IObjectFormElementExtension[]): void;
+    getElementExtensions(propertyName: string): Type<ObjectFormElementExtension>[];
+    /**
+     * Converts a form element object to an ObjectFormControlWrapper which then can be used to
+     * render a from control. Result can be used as input for FormElementComponent.
+     *
+     * @param element - the element object or a json string
+     * @param situation - optional property to set up a form situation for the control (default is EDIT)
+     * @return the converted ObjectFormControlWrapper or null in case of an error
+     */
+    elementToFormControl(element: any, situation?: string): ObjectFormControlWrapper | null;
+    /**
+     * Extract data from an object form based on situation.
+     *
+     * @param form - form to extract data from
+     * @param situation - form situation
+     * @param [initialData] - optional form data to match the current values against
+     * This is required for editig indexdata (EDIT situation), because we have to compare new values
+     * against the initial values. If a property that is contained in the forms initial data is removed
+     * (e.g. set to null) then we have to set this null value, because otherwise the server would
+     * ignore the changes.
+     * @param isTableRowEditForm Flag indicating that the provided form is an inline form used by
+     * a forms table element for editing rows. Those need a special handling.
+     * @return extracted data as object
+     */
+    extractFormData(form: ObjectFormGroup, situation: string, initialData?: any, isTableRowEditForm?: boolean): {};
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectFormService>;
+}

package/object-form/lib/object-form.utils.d.ts

@@ -0,0 +1,20 @@
+import { ObjectFormControlWrapper } from './object-form.interface';
+/**
+ * Provides a rendering of form control in `ObjectFormComponent`, `QuickSearchComponent` so wie `SearchFilterFormComponent`.
+ */
+export declare class ObjectFormUtils {
+    /**
+     * Converts a form element object to an ObjectFormControlWrapper which then can be used to
+     * render a from control. Result can be used as input for FormElementComponent.
+     *
+     * @param element - the element object or a json string
+     * @param situation - optional property to set up a form situation for the control (default is EDIT)
+     * @return the converted ObjectFormControlWrapper or null in case of an error
+     */
+    static elementToFormControl(formElement: any, situation?: string): ObjectFormControlWrapper;
+    /**
+     * Update a form element after change a form element object.
+     * @param formElement - the form element object
+     */
+    static updateFormElement(formElement: any): any;
+}

package/object-form/lib/object-form.validation.d.ts

@@ -0,0 +1,21 @@
+import { ValidatorFn } from '@angular/forms';
+/**
+ * @ignore
+ * Custom validation class.
+ */
+export declare class FormValidation {
+    /**
+     * Build validators for the given form element to be attached to
+     * a reactive formControl.
+     *
+     * @param formElement - form element object
+     * @param situation - form situation to fetch validators for
+     */
+    static getValidators(formElement: any, situation: string): ValidatorFn[];
+    /**
+     *
+     * @param control - from object control
+     * @returns Validation object {eoformScript: {valid: boolean}} or null
+     */
+    static customScriptingValidation(): ValidatorFn;
+}

package/object-preview/README.md

@@ -0,0 +1,3 @@
+# @yuuvis/client-framework/object-preview
+
+Secondary entry point of `@yuuvis/client-framework`. It can be used by importing from `@yuuvis/client-framework/object-preview`.

package/object-preview/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/components';
+export * from './lib/services/object-preview.service';

package/object-preview/lib/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './object-preview/object-preview.component';
+export * from './object-email-preview/object-email-preview.component';

package/object-preview/lib/components/object-email-preview/object-email-preview.component.d.ts

@@ -0,0 +1,16 @@
+import { DmsObject } from '@yuuvis/client-core';
+import * as i0 from "@angular/core";
+export declare class ObjectEmailPreviewComponent {
+    #private;
+    objectId: import("@angular/core").InputSignal<string | undefined>;
+    dmsObjectInput: import("@angular/core").InputSignal<DmsObject | undefined>;
+    dmsObject: import("@angular/core").Signal<DmsObject | undefined>;
+    viewerDetails: import("@angular/core").Signal<{
+        mediaViewerSrc: string;
+        id: string;
+        mimeType: string | undefined;
+        metadata: import("@yuuvis/media-viewer").EmailMetadata;
+    } | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectEmailPreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectEmailPreviewComponent, "yuv-object-email-preview", never, { "objectId": { "alias": "objectId"; "required": false; "isSignal": true; }; "dmsObjectInput": { "alias": "dmsObject"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}