@yuuvis/client-framework 3.9.0 → 3.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuuvis/client-framework",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "author": "OPTIMAL SYSTEMS GmbH <npm@optimal-systems.de>",
   "license": "MIT",
   "peerDependencies": {
@@ -8,16 +8,16 @@
     "@angular/common": "^21.2.9",
     "@angular/core": "^21.2.9",
     "angular-gridster2": "^21.0.1",
-    "@yuuvis/client-core": "^3.9.0",
-    "@yuuvis/client-shell-core": "^3.9.0",
-    "@yuuvis/client-components": "^3.9.0",
+    "@yuuvis/client-core": "^3.11.0",
+    "@yuuvis/client-shell-core": "^3.11.0",
+    "@yuuvis/client-components": "^3.11.0",
     "ng-dynamic-component": "^10.8.2",
     "modern-normalize": "^3.0.1"
   },
   "dependencies": {
     "@angular/material": "^21.2.7",
     "@ngrx/signals": "^21.1.0",
-    "@yuuvis/material": "^3.9.0",
+    "@yuuvis/material": "^3.11.0",
     "@yuuvis/media-viewer": "^3.0.6",
     "angular-split": "^20.0.0",
     "vis-network": "^10.0.2",

package/types/yuuvis-client-framework-metadata-form.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { TemplateRef, OnInit, AfterViewInit, OnDestroy } from '@angular/core';
+import { TemplateRef, InjectionToken, Signal, OnInit, AfterViewInit, OnDestroy } from '@angular/core';
 import { Situation, ObjectTypeField, ObjectFormControl } from '@yuuvis/client-core';
 import { AbstractControl } from '@angular/forms';
 import { Subject } from 'rxjs';
@@ -100,6 +100,27 @@ declare class MetadataFormElementRegistry {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<MetadataFormElementRegistry>;
 }
 
+/**
+ * Read-only view of the object a metadata form is rendered for. Exposed to
+ * element templates (`yuvMetadataElementTemplate`) via the field context.
+ *
+ * Intentionally minimal and framework-agnostic: it does NOT reference
+ * `DmsObject` so the token stays usable outside object-details (smart-search,
+ * BPM forms, …). Producers map their object onto this shape.
+ */
+interface ObjectContext {
+    id?: string;
+    objectTypeId?: string;
+    /** Immutable initial index data of the object (not live form edits). */
+    data: Record<string, unknown>;
+}
+/**
+ * Provide at the component that owns the object (e.g. `ObjectMetadataComponent`)
+ * so it is scoped to that instance's view subtree. Consumers inject it
+ * `{ optional: true }` — it is absent when a form runs standalone.
+ */
+declare const OBJECT_CONTEXT: InjectionToken<Signal<ObjectContext | undefined>>;
+
 /**
  * Context provided to each metadata form field.
  */
@@ -109,6 +130,8 @@ interface MetadataFormFieldContext {
     field: ObjectTypeField;
     ctrl?: AbstractControl<any, any>;
     formChangedSubject?: Subject<ParentFormChangedEvent>;
+    /** The object the form is rendered for. Undefined when no producer provided it. */
+    object?: ObjectContext;
 }
 interface ParentFormChangedEvent {
     invalid: boolean;
@@ -271,5 +294,5 @@ declare class MetadataFormFieldComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<MetadataFormFieldComponent, "yuv-metadata-form-field", never, { "formChangedSubject": { "alias": "formChangedSubject"; "required": false; "isSignal": true; }; "formField": { "alias": "field"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
 }
 
-export { MetadataFormElementRegistry, MetadataFormFieldComponent, ObjectMetadataElementErrorDirective, ObjectMetadataElementLabelDirective, ObjectMetadataElementRawDirective, ObjectMetadataElementTemplateDirective };
-export type { MetadataFormFieldContext, ParentFormChangedEvent };
+export { MetadataFormElementRegistry, MetadataFormFieldComponent, OBJECT_CONTEXT, ObjectMetadataElementErrorDirective, ObjectMetadataElementLabelDirective, ObjectMetadataElementRawDirective, ObjectMetadataElementTemplateDirective };
+export type { MetadataFormFieldContext, ObjectContext, ParentFormChangedEvent };

package/types/yuuvis-client-framework-object-details.d.ts

@@ -1,9 +1,9 @@
 import * as _angular_core from '@angular/core';
-import { TemplateRef, OnDestroy, PipeTransform } from '@angular/core';
+import { TemplateRef, OnDestroy, WritableSignal, PipeTransform } from '@angular/core';
 import * as _yuuvis_client_core from '@yuuvis/client-core';
 import { AuditQueryResult, AuditEntry, DmsObject, VirtualObjectType, RetentionState, TranslateService, ObjectTypeFlavor, Situation, FlavoredDmsObject, ObjectTypeField } from '@yuuvis/client-core';
 import { RendererDirectiveInput } from '@yuuvis/client-framework/renderer';
-import { ObjectFormComponent, IObjectFormElementExtension, ObjectFormOptions, FormStatusChangedEvent } from '@yuuvis/client-framework/object-form';
+import { ObjectFormComponent, IObjectFormElementExtension, ObjectFormOptions, FormStatusChangedEvent, SotRendererContext } from '@yuuvis/client-framework/object-form';
 import * as i7 from '@yuuvis/client-framework/common';
 import { FormGroup } from '@angular/forms';
 
@@ -183,14 +183,43 @@ declare class ObjectMetadataSectionComponent {
     expandedInput: _angular_core.InputSignal<boolean>;
     elementExtensions: _angular_core.InputSignal<IObjectFormElementExtension[]>;
     readonly: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * When `true`, the section's expand/collapse feature is removed: the content is
+     * always visible, cannot be collapsed, and the accordion toggle (arrow) is hidden.
+     */
+    skipExpand: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * When `true`, the section header (title, icon and toggle) is not rendered while the
+     * content region is still shown. Typically combined with {@link skipExpand} to display
+     * a title-less, always-open section.
+     */
+    skipTitle: _angular_core.InputSignal<boolean | undefined>;
     expanded: _angular_core.WritableSignal<boolean>;
+    /**
+     * Effective expanded state. When `skipExpand` is set the section is always visible
+     * and cannot be collapsed, so it is treated as permanently expanded.
+     */
+    isExpanded: _angular_core.Signal<boolean>;
     busy: _angular_core.WritableSignal<boolean>;
     formOptions: _angular_core.WritableSignal<ObjectFormOptions | undefined>;
     statusChanged: _angular_core.OutputEmitterRef<FormStatusChangedEvent>;
+    /**
+     * A custom SOT renderer registered for this section's SOT id, or undefined when
+     * the default schema-driven form should be used.
+     */
+    customTemplate: _angular_core.Signal<_angular_core.TemplateRef<any> | undefined>;
+    /**
+     * Last status emitted by a custom renderer. Used to drive the host dirty/invalid
+     * classes when the default `yuv-object-form` (and thus `objectForm()`) is absent.
+     */
+    customStatus: _angular_core.WritableSignal<FormStatusChangedEvent | undefined>;
+    renderCustom: _angular_core.Signal<boolean>;
+    sotContext: _angular_core.Signal<SotRendererContext>;
+    toggle(): void;
     resetForm(): void;
     setFormPristine(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ObjectMetadataSectionComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ObjectMetadataSectionComponent, "yuv-object-metadata-section", never, { "section": { "alias": "section"; "required": true; "isSignal": true; }; "expandedInput": { "alias": "expanded"; "required": false; "isSignal": true; }; "elementExtensions": { "alias": "elementExtensions"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "statusChanged": "statusChanged"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ObjectMetadataSectionComponent, "yuv-object-metadata-section", never, { "section": { "alias": "section"; "required": true; "isSignal": true; }; "expandedInput": { "alias": "expanded"; "required": false; "isSignal": true; }; "elementExtensions": { "alias": "elementExtensions"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "skipExpand": { "alias": "skipExpand"; "required": false; "isSignal": true; }; "skipTitle": { "alias": "skipTitle"; "required": false; "isSignal": true; }; }, { "statusChanged": "statusChanged"; }, never, never, true, never>;
 }
 
 declare class ObjectMetadataComponent implements OnDestroy {
@@ -200,8 +229,8 @@ declare class ObjectMetadataComponent implements OnDestroy {
     hasWritePermission: _angular_core.Signal<boolean>;
     objectForms: _angular_core.Signal<readonly ObjectFormComponent[]>;
     objectMetadataSectionForms: _angular_core.Signal<readonly ObjectMetadataSectionComponent[]>;
-    busySaving: _angular_core.WritableSignal<boolean>;
-    busyLoading: _angular_core.WritableSignal<boolean>;
+    busySaving: WritableSignal<boolean>;
+    busyLoading: WritableSignal<boolean>;
     disableControls: _angular_core.InputSignal<boolean>;
     /**
      * Set to 'true' to disable the basic metadata form. This will hide
@@ -210,7 +239,7 @@ declare class ObjectMetadataComponent implements OnDestroy {
      */
     disableBasicMetadata: _angular_core.InputSignal<boolean>;
     elementExtensions: _angular_core.InputSignal<IObjectFormElementExtension[]>;
-    controlsVisible: _angular_core.WritableSignal<boolean>;
+    controlsVisible: WritableSignal<boolean>;
     empty: _angular_core.Signal<boolean>;
     baseData: {
         label: string;
@@ -223,9 +252,9 @@ declare class ObjectMetadataComponent implements OnDestroy {
     /**
      * Set to 'true' to prevent all metadata from being edited
      */
-    formDisabled: _angular_core.WritableSignal<boolean>;
+    formDisabled: WritableSignal<boolean>;
     dmsObjectInput: _angular_core.InputSignal<DmsObject | undefined>;
-    dmsObject: _angular_core.WritableSignal<DmsObject | undefined>;
+    dmsObject: WritableSignal<DmsObject | undefined>;
     /**
      * @deprecated This input will be removed in the future.
      * Please migrate to using `dmsObject` and `flavors` inputs instead.
@@ -240,7 +269,7 @@ declare class ObjectMetadataComponent implements OnDestroy {
      * Emits the current state of the metadata form.
      */
     statusChanged: _angular_core.OutputEmitterRef<FormStatusChangedEvent>;
-    mainFormOptions: _angular_core.WritableSignal<ObjectFormOptions | undefined>;
+    mainFormOptions: WritableSignal<ObjectFormOptions | undefined>;
     mainFormOptionsIsLoading: _angular_core.Signal<boolean>;
     flavors: _angular_core.InputSignal<ObjectTypeFlavor[] | undefined>;
     flavorFormOptions: _angular_core.Signal<{

package/types/yuuvis-client-framework-object-form.d.ts

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
-import { Type, OnDestroy, AfterViewInit } from '@angular/core';
-import { YuvEvent, YuvUser, HttpOptions, ObjectFormGroup } from '@yuuvis/client-core';
+import { Type, OnDestroy, AfterViewInit, OnInit, TemplateRef } from '@angular/core';
+import { YuvEvent, YuvUser, HttpOptions, ObjectFormGroup, Situation } from '@yuuvis/client-core';
 import { Observable } from 'rxjs';
 
 interface IObjectForm {
@@ -284,5 +284,148 @@ declare class YuvObjectFormModule {
     static ɵinj: _angular_core.ɵɵInjectorDeclaration<YuvObjectFormModule>;
 }
 
-export { ObjectFormComponent, ObjectFormElementExtension, YuvObjectFormModule };
-export type { FormStatusChangedEvent, IObjectForm, IObjectFormElementExtension, IObjectFormElementExtensionComponentInput, ObjectFormModelChange, ObjectFormOptions };
+/**
+ * Directive to be applied to a `ng-template`. It registers the template as the
+ * renderer for a complete secondary object type (SOT / flavor) inside the object
+ * metadata form. When a SOT has a registered template, its section renders that
+ * template instead of the auto-generated field-by-field form.
+ *
+ * The template receives a `SotRendererContext` as its implicit context. Use it to
+ * push status changes upward (`ctx.setStatus`) and to react to reset/pristine
+ * commands (`ctx.command$`), keeping the shared form integration intact.
+ *
+ * A single template can be registered for one SOT or for several at once by
+ * passing an array of SOT ids to `sot`.
+ *
+ * @example
+ * <ng-template yuvMetadataSotTemplate="default" sot="sot:invoice" let-ctx>
+ *   <my-invoice-sot [ctx]="ctx" />
+ * </ng-template>
+ *
+ * @example
+ * <ng-template yuvMetadataSotTemplate="default" [sot]="['sot:invoice', 'sot:receipt']" let-ctx>
+ *   <my-invoice-sot [ctx]="ctx" />
+ * </ng-template>
+ */
+declare class ObjectMetadataSotTemplateDirective implements OnInit, OnDestroy {
+    #private;
+    /**
+     * Bucket to register the template. Use 'default' for templates that should be
+     * used across all situations.
+     */
+    yuvMetadataSotTemplate: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The secondary object type (SOT / flavor) id(s) to register the template for.
+     * Pass a single id or an array of ids to reuse the same template for multiple SOTs.
+     */
+    sot: _angular_core.InputSignal<string | string[]>;
+    /**
+     * Situation to register the template for. So only object forms for that
+     * situation (CREATE, EDIT, SEARCH) will use the template. Defaults to `EDIT`.
+     */
+    situation: _angular_core.InputSignal<Situation>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ObjectMetadataSotTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ObjectMetadataSotTemplateDirective, "[yuvMetadataSotTemplate]", never, { "yuvMetadataSotTemplate": { "alias": "yuvMetadataSotTemplate"; "required": false; "isSignal": true; }; "sot": { "alias": "sot"; "required": true; "isSignal": true; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Metadata forms render each applied secondary object type (SOT / flavor) as its
+ * own section. By default a section auto-generates a field-by-field form from the
+ * SOT's schema. This registry lets you replace the body of a SOT's section with a
+ * custom template so you can render all of the SOT's properties in one freely
+ * designed component (a compact header, a computed summary widget, ...) while the
+ * surrounding save/reset/pristine machinery stays intact.
+ *
+ * Templates are keyed by SOT id and can be registered per situation (EDIT, SEARCH,
+ * CREATE). Registering with the `default` bucket makes a template apply across all
+ * situations. Registration is normally done declaratively via the
+ * `yuvMetadataSotTemplate` directive.
+ */
+declare class SotRendererRegistry {
+    private _defaults;
+    private _edit;
+    private _search;
+    private _create;
+    /**
+     * Get the template to render a certain SOT with. Defaults are always merged in,
+     * then overlaid by the situation-specific map.
+     * @param sot The secondary object type id to get the template for
+     * @param situation Form situation
+     * @returns TemplateRef or undefined
+     */
+    getSotTemplate(sot: string, situation?: string): TemplateRef<any> | undefined;
+    /**
+     * Register a template for rendering a certain SOT.
+     * @param sot The secondary object type id to provide the template for
+     * @param templateRef The template
+     * @param situation Form situation to provide the template for (defaults to EDIT)
+     */
+    addSotTemplate(sot: string, templateRef: TemplateRef<any>, situation?: Situation): void;
+    /**
+     * Remove a registered SOT template.
+     * @param sot The secondary object type id to remove the template for
+     * @param situation Form situation (defaults to EDIT)
+     */
+    removeSotTemplate(sot: string, situation?: Situation): void;
+    /**
+     * Register a default SOT template (used across all situations).
+     * @param sot The secondary object type id to provide the template for
+     * @param templateRef The default template
+     */
+    _addDefaultSotTemplate(sot: string, templateRef: TemplateRef<any>): void;
+    /**
+     * Remove a registered default SOT template.
+     * @param sot The secondary object type id to remove the template for
+     */
+    _removeDefaultSotTemplate(sot: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SotRendererRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SotRendererRegistry>;
+}
+
+/**
+ * Command pushed from the metadata form down into a custom SOT renderer.
+ * - `reset`: restore the renderer to its initially loaded data (user hit "reset")
+ * - `pristine`: mark the renderer clean (a save succeeded)
+ */
+type SotRendererCommand = {
+    type: 'reset' | 'pristine';
+};
+/**
+ * Context object handed to a template registered via `yuvMetadataSotTemplate`.
+ * Passed as `$implicit`, so pick it up with `let-ctx`.
+ *
+ * It is the two-way bridge between the custom renderer and the surrounding
+ * metadata form:
+ * - OUTBOUND: call `setStatus()` whenever your form changes so its dirty/invalid
+ *   state and value payload flow into the shared save/reset/pristine machinery.
+ * - INBOUND: subscribe to `command$` to react to reset/pristine triggered by the
+ *   metadata form (e.g. the user hitting "reset" or a successful save).
+ */
+interface SotRendererContext {
+    /** The secondary object type (SOT / flavor) id this renderer was registered for. */
+    sot: string;
+    /** Form situation the metadata form is running in. */
+    situation: Situation;
+    /** Whether the section is readonly (e.g. missing write permission or a lock). */
+    readonly: boolean;
+    /**
+     * The SOT's form model as loaded by the section. May be `undefined` for a fully
+     * custom renderer that does not rely on the schema-driven model.
+     */
+    formModel: any;
+    /** The SOT's current data slice (property/value pairs). */
+    data: Record<string, unknown>;
+    /**
+     * OUTBOUND. Push a status whenever your form changes. The `data` you provide
+     * must be keyed by real property names — it is flat-merged into the object's
+     * save payload alongside every other section.
+     */
+    setStatus: (evt: FormStatusChangedEvent) => void;
+    /** INBOUND. Emits when the metadata form asks the renderer to reset or go pristine. */
+    command$: Observable<SotRendererCommand>;
+}
+
+export { ObjectFormComponent, ObjectFormElementExtension, ObjectMetadataSotTemplateDirective, SotRendererRegistry, YuvObjectFormModule };
+export type { FormStatusChangedEvent, IObjectForm, IObjectFormElementExtension, IObjectFormElementExtensionComponentInput, ObjectFormModelChange, ObjectFormOptions, SotRendererCommand, SotRendererContext };