@smartbit4all/ng-client 5.0.21 → 6.0.1

package/esm2022/lib/view-context/smart-view-context.service.mjs

@@ -0,0 +1,1074 @@
+import { Inject, Injectable, InjectionToken, Optional, } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { LinkTargetEnum, ViewState, ViewType, } from './api';
+import { MessageDialogComponent } from './message-dialog/message-dialog.component';
+import { SmartSubject } from '../smart-subject/projects';
+import { MatDialogRef } from '@angular/material/dialog';
+import { DynamicDialogRef } from 'primeng/dynamicdialog';
+import { COMPONENT_LIBRARY } from './utility/componentLibrary';
+import { resolveSlot } from './view-slot-resolution';
+import { SMART_DEFAULT_VIEW_COMPONENTS, } from './default-view-components.token';
+import { resolveViewHandler } from './view-handler-resolution';
+import { buildViewOps } from './view-op';
+import { REUSE_ROUTER_SLOT_COMPONENT } from './reuse-router-slot.token';
+import * as i0 from "@angular/core";
+import * as i1 from "./api";
+import * as i2 from "../session/smart-session.service";
+import * as i3 from "./smart-view-context-dialog.service";
+import * as i4 from "./utility/componentLibrary";
+export const SmartViewContextErrorDialogButtonLabel = 'SmartViewContextErrorDialogButtonLabel';
+export const SmartViewContextErrorDialogTitle = 'SmartViewContextErrorDialogTitle';
+export const SmartViewContextErrorDialogMessage = 'SmartViewContextErrorDialogMessage';
+export const DefaultUiActionCode_CLOSE = 'DEFAULT_CLOSE';
+export const DIALOG_DISABLE_CLOSE = new InjectionToken('dialogDisableClose');
+export class SmartViewContextService {
+    set translateService(translateService) {
+        this._translateService = translateService;
+        this.translateServiceChanged.next();
+        this.translateServiceChanged.complete();
+    }
+    get translateService() {
+        if (this._translateService) {
+            return this._translateService;
+        }
+        return undefined;
+    }
+    constructor(view, session, dialog, apiQueueService, inject, compLib, defaultViewComponents) {
+        this.view = view;
+        this.session = session;
+        this.dialog = dialog;
+        this.apiQueueService = apiQueueService;
+        this.inject = inject;
+        this.viewContextUuidName = 'viewContextUuid';
+        this.viewContextUuidHeaderName = 'viewContextUuid';
+        this.pageNamePrefix = 'page.';
+        this.componentNamePrefix = 'component.';
+        this.viewHandlers = new Array();
+        this.defaultComponents = new Map();
+        this.openedViewUuids = new Array();
+        this.openedViewData = new Array();
+        // Monotonic counter bumped on every successful startViewContext(). Callers
+        // that hold a reference to a view-uuid from a previous viewcontext can
+        // detect a rebuild by comparing snapshots of this value.
+        this.generation = 0;
+        this._destroy$ = new Subject();
+        this.uuidOfPageHasBeenChanged = new SmartSubject(this._destroy$);
+        this.viewContextHasBeenSynced = new SmartSubject(this._destroy$);
+        this.openSmartLink = new SmartSubject(this._destroy$);
+        this.isOpeningSmartLink = false;
+        this.dialogRefs = [];
+        this.embeddedContainers = new Map();
+        this.embeddedViewRefs = [];
+        this.pendingEmbeddedViews = [];
+        this.smartApiClients = new Map();
+        this.translateServiceChanged = new SmartSubject(this._destroy$);
+        this.componentLibrary = compLib;
+        for (const entry of defaultViewComponents ?? []) {
+            this.defaultComponents.set(entry.componentName, entry.component);
+        }
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    follow(uuid, detectChange) {
+        this.smartApiClients.set(uuid, detectChange);
+    }
+    unfollow(uuid) {
+        this.smartApiClients.delete(uuid);
+    }
+    registerEmbeddedSlot(containerUuid, containerId, vcRef, kind) {
+        let innerMap = this.embeddedContainers.get(containerUuid);
+        if (!innerMap) {
+            innerMap = new Map();
+            this.embeddedContainers.set(containerUuid, innerMap);
+        }
+        innerMap.set(containerId, { vcRef, kind });
+        // Reattach embedded views that were detached before layout re-render
+        const existing = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid && ref.containerId === containerId);
+        for (const ref of existing) {
+            if (!ref.componentRef.hostView.destroyed) {
+                vcRef.insert(ref.componentRef.hostView);
+            }
+        }
+        // Drain pending queue (match on the resolved slot, so router-slot NORMAL views match too)
+        const matches = (v) => {
+            const s = resolveSlot(v);
+            return s.containerUuid === containerUuid && s.containerId === containerId;
+        };
+        const matching = this.pendingEmbeddedViews.filter(matches);
+        this.pendingEmbeddedViews = this.pendingEmbeddedViews.filter((v) => !matches(v));
+        if (matching.length > 0) {
+            const updates = matching.map((v) => this.openView(v));
+            this.sendViewContextUpdates(updates);
+        }
+    }
+    detachAllEmbeddedViews(containerUuid) {
+        const children = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid);
+        for (const child of children) {
+            if (child.componentRef.hostView.destroyed) {
+                continue;
+            }
+            // Only detach views living in a re-rendering LAYOUT slot. A STABLE directive
+            // slot (router-outlet) lives outside the layout *ngFor and survives the parent
+            // re-render, so its child needs no detach protection — detaching it here is
+            // what produced the false-orphan destroy in multi-level NORMAL nesting
+            // (Home -> Main -> page): Main got swept up by Home's layout dance. (#28870)
+            const entry = this.embeddedContainers.get(containerUuid)?.get(child.containerId);
+            if (!entry || entry.kind === 'stable') {
+                continue;
+            }
+            const idx = entry.vcRef.indexOf(child.componentRef.hostView);
+            if (idx >= 0) {
+                entry.vcRef.detach(idx);
+            }
+        }
+    }
+    cleanupOrphanedEmbeddedViews(containerUuid) {
+        const refs = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid);
+        const orphaned = [];
+        for (const ref of refs) {
+            if (ref.componentRef.hostView.destroyed) {
+                orphaned.push(ref);
+                continue;
+            }
+            const vcRef = this.getEmbeddedSlot(containerUuid, ref.containerId);
+            if (!vcRef) {
+                // The slot is truly gone (its layout host was torn down and not recreated):
+                // a real orphan to destroy. A LAYOUT slot that came back re-registers and
+                // reattaches its child (registerEmbeddedSlot); a STABLE slot is never detached
+                // in the first place. So a still-registered slot here always holds its view —
+                // no reattach branch is needed (that branch only ever patched the stable
+                // false-orphan, which detachAllEmbeddedViews no longer creates). (#28870)
+                orphaned.push(ref);
+                continue;
+            }
+        }
+        for (const ref of orphaned) {
+            if (!ref.componentRef.hostView.destroyed) {
+                ref.componentRef.destroy();
+            }
+            const idx = this.openedViewUuids.indexOf(ref.uuid);
+            if (idx >= 0) {
+                this.openedViewUuids.splice(idx, 1);
+                this.openedViewData.splice(idx, 1);
+            }
+        }
+        this.embeddedViewRefs = this.embeddedViewRefs.filter((ref) => !orphaned.includes(ref));
+    }
+    getCompositeModel(containerUuid) {
+        const result = {};
+        const children = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid);
+        for (const child of children) {
+            result[child.uuid] = child.componentRef.instance.getModel();
+            Object.assign(result, this.getCompositeModel(child.uuid));
+        }
+        return result;
+    }
+    submitEmbeddedForms(containerUuid, validate) {
+        const allInvalidKeys = [];
+        const allInvalidNames = [];
+        const children = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid);
+        for (const child of children) {
+            const instance = child.componentRef.instance;
+            instance.submitForm(validate);
+            if (validate) {
+                const invalid = instance.getInvalidFields();
+                allInvalidKeys.push(...invalid.invalidFieldKeys);
+                allInvalidNames.push(...invalid.invalidFieldNames);
+            }
+            const nested = this.submitEmbeddedForms(child.uuid, validate);
+            allInvalidKeys.push(...nested.invalidFieldKeys);
+            allInvalidNames.push(...nested.invalidFieldNames);
+        }
+        return { invalidFieldKeys: allInvalidKeys, invalidFieldNames: allInvalidNames };
+    }
+    unregisterEmbeddedSlot(containerUuid, containerId) {
+        const innerMap = this.embeddedContainers.get(containerUuid);
+        if (innerMap) {
+            innerMap.delete(containerId);
+            if (innerMap.size === 0) {
+                this.embeddedContainers.delete(containerUuid);
+            }
+        }
+    }
+    getEmbeddedSlot(containerUuid, containerId) {
+        return this.embeddedContainers.get(containerUuid)?.get(containerId)?.vcRef;
+    }
+    /**
+     * Create the view's component into its resolved slot. Returns false and queues
+     * the view if the slot is not registered yet (drained on registration).
+     */
+    insertViewIntoSlot(view, component) {
+        const { containerUuid, containerId } = resolveSlot(view);
+        const vcRef = this.getEmbeddedSlot(containerUuid, containerId);
+        if (!vcRef) {
+            // Slot not registered yet: queue the view and drain it when its slot registers
+            // (registerEmbeddedSlot). The synchronous detectChanges below renders a freshly
+            // mounted parent's template in the same syncView pass, so a parent -> child ->
+            // grandchild chain (Home -> Main -> page) registers every slot immediately and
+            // the queue drains within the pass — even when restoreViews opens a child before
+            // its parent. (#28870)
+            this.pendingEmbeddedViews.push(view);
+            return false;
+        }
+        const componentRef = vcRef.createComponent(component);
+        componentRef.instance.uuid = view.uuid;
+        this.embeddedViewRefs.push({ uuid: view.uuid, containerUuid, containerId, componentRef });
+        // Render the freshly created component synchronously so its own embedded-slot
+        // directives (the router-outlet slot of a nested NORMAL view) register their
+        // containers immediately. This lets a parent -> child -> grandchild chain
+        // (e.g. Home -> Main -> page) mount in a single synchronous syncView pass
+        // instead of depending on a change-detection tick firing between each level.
+        // Without it the child cannot resolve its slot, queues into
+        // pendingEmbeddedViews, and the drain races the async updateViewContext
+        // round-trips — intermittently leaving a parent OPENED in backend bookkeeping
+        // but never mounted on the client, so its slot child stays blank. (#28870)
+        componentRef.changeDetectorRef.detectChanges();
+        componentRef.instance.run();
+        return true;
+    }
+    setActionDescriptors(actionDescriptors) {
+        this.actionDescriptors = actionDescriptors;
+    }
+    getActionDescriptors() {
+        if (!this.actionDescriptors) {
+            console.error('No action descriptors has been set to ViewContext.');
+        }
+        return this.actionDescriptors;
+    }
+    setViewHandlers(viewHandlers) {
+        this.viewHandlers = viewHandlers;
+    }
+    setViewApiErrors(viewApiErrors) {
+        this.smartViewContextApiErrors = viewApiErrors;
+    }
+    setMessageDialogName(messageDialogName) {
+        this.messageDialogname = messageDialogName;
+        this.viewHandlers.push({
+            name: messageDialogName,
+            component: MessageDialogComponent,
+        });
+    }
+    setUpUrlForViewService() {
+        this.view.configuration.basePath = this.url;
+    }
+    getModuleURL(module) {
+        if (!this.moduleUrlsByModule) {
+            throw new Error('ModulesMap does not exist.');
+        }
+        let moduleUrl = this.moduleUrlsByModule?.get(module);
+        if (!moduleUrl) {
+            throw new Error('ModuleUrl does not exist with the given module.');
+        }
+        return moduleUrl;
+    }
+    setModuleURL(modules) {
+        this.moduleUrlsByModule = modules;
+    }
+    setUrl(url) {
+        this.url = url + '/view';
+        this.setUpUrlForViewService();
+    }
+    async getAndSyncViewContext(uuid) {
+        if (!uuid) {
+            uuid = this.getViewContextUuid();
+        }
+        await this.getViewContext(uuid).then(async () => {
+            await this.syncView();
+        });
+    }
+    async getViewContext(uuid) {
+        this.viewContext = await this.view.getViewContext(uuid).toPromise();
+        if (!this.viewContext) {
+            throw new Error('ViewContext does not exist with the given uuid.');
+        }
+        return this.viewContext;
+    }
+    async getViewContextDataByPageName(pageName) {
+        if (!this.viewContext) {
+            await this.getViewContext(this.getViewContextUuid());
+        }
+        let pageUuid = this.getUuidOfPage(pageName);
+        let viewContextByPageName = this.viewContext?.views.find((view) => view.uuid === pageUuid);
+        if (!viewContextByPageName) {
+            throw new Error(`The ViewData of ${pageName} is not found!`);
+        }
+        return viewContextByPageName;
+    }
+    async updateViewContext(viewContextUpdate) {
+        viewContextUpdate.deviceInfo ??= {
+            deviceId: 'id',
+            userAgent: navigator.userAgent,
+            parameters: new Map(),
+        };
+        viewContextUpdate.deviceInfo.componentLibrary = this.componentLibrary;
+        this.viewContext = await this.view.updateViewContext(viewContextUpdate).toPromise();
+        return this.viewContext;
+    }
+    clearSessionStorage() {
+        sessionStorage.clear();
+        this.clearEmbeddedViews();
+        this.openedViewData = [];
+        this.openedViewUuids = [];
+    }
+    /**
+     * Tear down all slot-hosted view components on a viewContext reset (e.g. logout /
+     * viewcontext-lost). Without this the previous view tree stays mounted in the root
+     * slot and the new tree is appended alongside it. Destroying a parent cascades to
+     * its nested slot directives (which unregister their containers via ngOnDestroy),
+     * leaving only the host-owned root slot registered.
+     */
+    clearEmbeddedViews() {
+        for (const ref of this.embeddedViewRefs) {
+            if (!ref.componentRef.hostView.destroyed) {
+                ref.componentRef.destroy();
+            }
+        }
+        this.embeddedViewRefs = [];
+        this.pendingEmbeddedViews = [];
+    }
+    async startViewContext() {
+        this.clearSessionStorage();
+        this.session.addHeaderParam({
+            headerName: this.viewContextUuidHeaderName,
+            value: '',
+        });
+        let newViewContext = await this.view
+            .createViewContext()
+            .toPromise();
+        if (!newViewContext) {
+            throw new Error('No ViewContext was created');
+        }
+        this.viewContext = newViewContext;
+        this.setViewContextUuid(newViewContext.uuid);
+        this.generation++;
+        return this.viewContext;
+    }
+    getGeneration() {
+        return this.generation;
+    }
+    async initialize(uuid) {
+        if (this.initializeRunning) {
+            return this.initializeRunning.toPromise();
+        }
+        else {
+            this.initializeRunning = new SmartSubject(this._destroy$);
+            try {
+                if (this.viewHandlers.length === 0) {
+                    throw new Error("There aren't any viewHandlers in SmartViewContextService! Provide some to use its functions.");
+                }
+                if (!this.messageDialogname) {
+                    throw new Error('The messageDialogName provided by the backend has not been set.');
+                }
+                if (uuid) {
+                    this.setViewContextUuid(uuid);
+                    try {
+                        await this.getViewContext(uuid);
+                    }
+                    catch (err) {
+                        await this.startViewContext();
+                    }
+                }
+                else {
+                    await this.startViewContext();
+                }
+                return this.viewContext;
+            }
+            finally {
+                this.initializeRunning.next(this.viewContext);
+                this.initializeRunning.complete();
+                this.initializeRunning = undefined;
+            }
+        }
+    }
+    async initViewContext() {
+        let uuid;
+        try {
+            uuid = this.getViewContextUuid();
+        }
+        catch (error) {
+            await this.initialize();
+            uuid = this.getViewContextUuid();
+        }
+        await this.initialize(uuid);
+        await this.restoreViews(uuid);
+        await this.getAndSyncViewContext();
+    }
+    /**
+     * Hydrates the view-context state from an already-existing UUID provided
+     * externally (e.g. by a native mobile shell via URL fragment). Unlike
+     * `initialize(uuid)`, this method does NOT fall back to creating a fresh
+     * viewContext if the backend rejects the UUID — the caller is expected to
+     * surface the failure (typically via the bootstrap's `onStartError` hook).
+     */
+    async initFromExistingViewContext(uuid) {
+        this.setViewContextUuid(uuid);
+        await this.getViewContext(uuid);
+        await this.restoreViews(uuid);
+    }
+    async initNewViewContext() {
+        if (this.initiNewContextRunning) {
+            return this.initiNewContextRunning.toPromise();
+        }
+        this.initiNewContextRunning = new SmartSubject(this._destroy$);
+        try {
+            await this.startViewContext();
+            let uuid = this.getViewContextUuid();
+            await this.initialize(uuid);
+            await this.restoreViews(uuid);
+        }
+        finally {
+            this.initiNewContextRunning.next();
+            this.initiNewContextRunning.complete();
+            this.initiNewContextRunning = undefined;
+        }
+    }
+    openView(view) {
+        let alreadyOpened = this.openedViewUuids.some((uuid) => uuid === view.uuid);
+        if (alreadyOpened)
+            return undefined;
+        const viewHandler = resolveViewHandler(this.viewHandlers, this.defaultComponents, view);
+        if (!viewHandler) {
+            throw new Error(`SmartViewHandlerModel was not found by view name: ${view.viewName} (componentName: ${view.componentName})`);
+        }
+        if (view.type === ViewType.DIALOG) {
+            if (!viewHandler.component) {
+                throw new Error(`Component is undefined in SmartViewHandlerModel with name: ${view.viewName}`);
+            }
+            let refIsAlradyAdded = this.dialogRefs.some((ref) => ref.uuid === view.uuid);
+            if (!refIsAlradyAdded) {
+                let dialogRef;
+                try {
+                    this.openedViewUuids.push(view.uuid);
+                    this.openedViewData.push(view);
+                    this.setUuidOfPage(view.viewName, view.uuid, viewHandler.componentName);
+                    dialogRef = this.dialog.openComponentAsDialog(viewHandler.component, viewHandler.name, view.uuid);
+                }
+                finally {
+                    const index = this.openedViewUuids.indexOf(view.uuid);
+                    if (index >= 0) {
+                        this.openedViewUuids.splice(index, 1);
+                        this.openedViewData.splice(index, 1);
+                        this.clearUuidOfPage(view.viewName, viewHandler.componentName);
+                    }
+                    this.setUuidOfPage(view.viewName, view.uuid, viewHandler.componentName);
+                }
+                let dialogDisableClose = true;
+                let isMessageDialog = view.viewName === this.messageDialogname;
+                if (!isMessageDialog) {
+                    try {
+                        dialogDisableClose = this.inject.get(DIALOG_DISABLE_CLOSE);
+                    }
+                    catch {
+                        console.error('Error during reading DIALOG_DISABLE_CLOSE');
+                    }
+                }
+                if (dialogRef instanceof MatDialogRef) {
+                    dialogRef.disableClose = dialogDisableClose;
+                    // if (isMessageDialog) {
+                    //   if (view.message?.options && view.message.options.length) {
+                    //   }
+                    // }
+                    if (!dialogDisableClose) {
+                        dialogRef
+                            .afterClosed()
+                            .pipe(takeUntil(this._destroy$))
+                            .subscribe(() => {
+                            this.performAction(view.uuid, { code: DefaultUiActionCode_CLOSE, params: {} });
+                        });
+                    }
+                }
+                else if (dialogRef instanceof DynamicDialogRef) {
+                    if (!dialogDisableClose) {
+                        dialogRef.onDestroy.pipe(takeUntil(this._destroy$)).subscribe(() => {
+                            this.performAction(view.uuid, { code: DefaultUiActionCode_CLOSE, params: {} });
+                        });
+                    }
+                }
+                this.dialogRefs.push({
+                    uuid: view.uuid,
+                    dialogRef,
+                });
+            }
+        }
+        else if (view.type === ViewType.NORMAL) {
+            if (!viewHandler.component) {
+                throw new Error(`Component is undefined in SmartViewHandlerModel with name: ${view.viewName}`);
+            }
+            // COMPATIBILITY SHIM (#28870, intentional): some child services (SmarttreeGenericService,
+            // SmartFilterEditorService) and generic components (SearchPageComponent, GenericPageComponent)
+            // still resolve their view uuid via the pageName -> getUuidOfPage(sessionStorage) indirection
+            // in their CONSTRUCTOR, which runs inside createComponent() below — before openView's normal
+            // bookkeeping. So the mapping must be written here, ahead of component creation. The proper
+            // fix (feed those consumers the injected uuid + defer their init) is deferred consumer plumbing;
+            // until then this write keeps the indirection correct in the slot world.
+            this.setUuidOfPage(view.viewName, view.uuid, viewHandler.componentName);
+            // A NORMAL view with no containerUuid lands in the host root slot (resolveSlot maps
+            // it to ROOT_CONTAINER_UUID); if no slot is registered yet it queues and drains later.
+            const inserted = this.insertViewIntoSlot(view, viewHandler.component);
+            if (!inserted)
+                return undefined;
+        }
+        else if (view.type === ViewType.EMBEDDED) {
+            if (!viewHandler.component) {
+                throw new Error(`Component is undefined in SmartViewHandlerModel with name: ${view.viewName}`);
+            }
+            // Write the page-uuid mapping ahead of component creation so constructor-time
+            // and nested getUuidOfPage(viewName) consumers (filter, tree) resolve. The
+            // page.<viewName> key is distinct per view, so it never collides. The
+            // component.<componentName> reverse key CAN be overwritten by another
+            // concurrent dynamic view of the same default component, but it is read only
+            // synchronously in the constructor (right after this write) and slot views
+            // load via the injected _uuid afterwards, so the overwrite never mis-resolves
+            // at runtime. (#28870)
+            this.setUuidOfPage(view.viewName, view.uuid, viewHandler.componentName);
+            const inserted = this.insertViewIntoSlot(view, viewHandler.component);
+            if (!inserted)
+                return undefined;
+        }
+        else {
+            throw new Error('The type of the view and its viewHandler is not the same!');
+        }
+        view.state = ViewState.OPENED;
+        this.openedViewUuids.push(view.uuid);
+        this.openedViewData.push(view);
+        if (view.type !== ViewType.EMBEDDED) {
+            this.setUuidOfPage(view.viewName, view.uuid, viewHandler.componentName);
+            this.uuidOfPageHasBeenChanged.next(view.viewName);
+        }
+        return {
+            state: ViewState.OPENED,
+            uuid: view.uuid,
+        };
+    }
+    closeView(view) {
+        const viewHandler = resolveViewHandler(this.viewHandlers, this.defaultComponents, view);
+        if (!viewHandler) {
+            throw new Error(`SmartViewHandlerModel was not found by view name: ${view.viewName} (componentName: ${view.componentName})`);
+        }
+        const updates = [];
+        if (view.type === ViewType.DIALOG) {
+            let dialogRef = this.dialogRefs.find((dialogRef) => dialogRef.uuid === view.uuid);
+            if (dialogRef) {
+                dialogRef.dialogRef.close();
+                let index = this.dialogRefs.indexOf(dialogRef);
+                this.dialogRefs.splice(index, 1);
+            }
+            else {
+                // console.log('DialogRef is not found by uuid.');
+            }
+            updates.push(...this.cleanupEmbeddedChildren(view.uuid));
+        }
+        else if (view.type === ViewType.NORMAL) {
+            // Destroy nested children first, then the view's own slot component.
+            // destroyViewRef is a no-op for the legacy route-rendered (rootless) case.
+            updates.push(...this.cleanupEmbeddedChildren(view.uuid));
+            this.destroyViewRef(view.uuid);
+        }
+        else if (view.type === ViewType.EMBEDDED) {
+            this.destroyViewRef(view.uuid);
+        }
+        else {
+            throw new Error('The type of the view and its viewHandler is not the same!');
+        }
+        view.state = ViewState.CLOSED;
+        const index = this.openedViewUuids.indexOf(view.uuid);
+        if (index >= 0) {
+            this.openedViewUuids.splice(index, 1);
+            this.openedViewData.splice(index, 1);
+            // Clear for every type: openView now writes the page-uuid mapping for
+            // EMBEDDED views too (#28870), so the clear must be symmetric to avoid a
+            // stale sessionStorage entry. clearUuidOfPage is a no-op for keys never
+            // written, so this stays safe for the legacy rootless case.
+            this.clearUuidOfPage(view.viewName, viewHandler.componentName);
+        }
+        updates.push({
+            state: ViewState.CLOSED,
+            uuid: view.uuid,
+        });
+        return updates;
+    }
+    cleanupEmbeddedChildren(containerUuid) {
+        const updates = [];
+        const children = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid);
+        for (const child of children) {
+            child.componentRef.destroy();
+            updates.push({ state: ViewState.CLOSED, uuid: child.uuid });
+        }
+        this.embeddedViewRefs = this.embeddedViewRefs.filter((ref) => ref.containerUuid !== containerUuid);
+        this.pendingEmbeddedViews = this.pendingEmbeddedViews.filter((v) => v.containerUuid !== containerUuid);
+        this.embeddedContainers.delete(containerUuid);
+        return updates;
+    }
+    /** Destroy the component for a view living in a slot, if present (no-op for route-rendered views). */
+    destroyViewRef(uuid) {
+        const refIndex = this.embeddedViewRefs.findIndex((ref) => ref.uuid === uuid);
+        if (refIndex >= 0) {
+            this.embeddedViewRefs[refIndex].componentRef.destroy();
+            this.embeddedViewRefs.splice(refIndex, 1);
+        }
+        this.pendingEmbeddedViews = this.pendingEmbeddedViews.filter((v) => v.uuid !== uuid);
+    }
+    async sendViewContextUpdates(updatesToSend) {
+        const updates = [];
+        updatesToSend.forEach((update) => {
+            if (update !== undefined && update !== null)
+                updates.push(update);
+        });
+        if (updates.length > 0) {
+            await this.updateViewContext({
+                updates,
+                uuid: this.viewContext?.uuid,
+            });
+        }
+    }
+    async restoreViews(uuid) {
+        const updates = [];
+        if (!this.viewContext) {
+            await this.getViewContext(uuid);
+        }
+        this.viewContext.views.filter((view) => view.state === ViewState.OPENED || view.state === ViewState.TO_OPEN).map((view) => {
+            const update = this.openView(view);
+            if (update) {
+                updates.push(update);
+            }
+        });
+        await this.sendViewContextUpdates(updates);
+    }
+    reuseEnabled() {
+        try {
+            const value = this.inject.get(REUSE_ROUTER_SLOT_COMPONENT);
+            return value !== false; // default ON when unset/null
+        }
+        catch {
+            return true;
+        }
+    }
+    executeReuse(oldView, newView) {
+        const ref = this.embeddedViewRefs.find((r) => r.uuid === oldView.uuid);
+        if (!ref) {
+            // No live component to reuse (e.g. was route-rendered) — fall back to close + open.
+            const updates = [...this.closeView(oldView)];
+            const opened = this.openView(newView);
+            if (opened)
+                updates.push(opened);
+            return updates;
+        }
+        // The reused parent is logically a fresh page (new uuid); its previous embedded
+        // children do not carry over (the backend leaves them keyed under the old parent
+        // uuid). Tear them down here and report them CLOSED.
+        const childUpdates = this.cleanupEmbeddedChildren(oldView.uuid);
+        ref.componentRef.instance.uuid = newView.uuid; // setter runs unfollow(old)/follow(new)
+        ref.uuid = newView.uuid;
+        const oldIdx = this.openedViewUuids.indexOf(oldView.uuid);
+        if (oldIdx >= 0) {
+            this.openedViewUuids.splice(oldIdx, 1);
+            this.openedViewData.splice(oldIdx, 1);
+        }
+        this.openedViewUuids.push(newView.uuid);
+        this.openedViewData.push(newView);
+        ref.componentRef.instance.run();
+        oldView.state = ViewState.CLOSED;
+        newView.state = ViewState.OPENED;
+        // Mirror the normal openView tail so getUuidOfPage consumers (e.g. trees) resolve the new uuid.
+        const viewHandler = resolveViewHandler(this.viewHandlers, this.defaultComponents, newView);
+        this.setUuidOfPage(newView.viewName, newView.uuid, viewHandler?.componentName);
+        this.uuidOfPageHasBeenChanged.next(newView.viewName);
+        return [
+            ...childUpdates,
+            { state: ViewState.CLOSED, uuid: oldView.uuid },
+            { state: ViewState.OPENED, uuid: newView.uuid },
+        ];
+    }
+    async syncView() {
+        const updates = [];
+        const ops = buildViewOps(this.viewContext?.views ?? [], this.reuseEnabled());
+        for (const op of ops) {
+            if (op.kind === 'open') {
+                updates.push(this.openView(op.view));
+            }
+            else if (op.kind === 'close') {
+                updates.push(...this.closeView(op.view));
+            }
+            else {
+                updates.push(...this.executeReuse(op.oldView, op.newView));
+            }
+        }
+        const viewDataToClose = this.openedViewData.filter((viewData) => !this.viewContext?.views
+            .flatMap((viewData) => viewData.uuid)
+            .includes(viewData.uuid));
+        if (viewDataToClose?.length) {
+            viewDataToClose.map((viewData) => {
+                updates.push(...this.closeView(viewData));
+            });
+        }
+        this.viewContext?.links?.map((data) => {
+            const link = document.createElement('a');
+            let target = '_blank'; // default
+            switch (data.target ?? LinkTargetEnum.BLANK) {
+                case 'SELF':
+                    target = '_self';
+                    break;
+                case 'BLANK':
+                    target = '_blank';
+                    break;
+                case 'PARENT':
+                    target = '_parent';
+                    break;
+                case 'TOP':
+                    target = '_top';
+                    break;
+            }
+            link.setAttribute('target', target);
+            link.setAttribute('href', data.url);
+            if (data.download) {
+                link.setAttribute('download', data.filename ?? '');
+            }
+            document.body.appendChild(link);
+            link.click();
+            link.remove();
+        });
+        this.startDownloadsFiles(this.viewContext?.downloads || []);
+        const clipboardText = this.viewContext?.clipboardData
+            ?.map((cd) => cd.text || '')
+            .join('');
+        if (clipboardText) {
+            const clipboard = navigator.clipboard;
+            // available only in secure contexts.
+            if (clipboard) {
+                try {
+                    clipboard
+                        .writeText(clipboardText)
+                        .catch((e) => console.error('Failed to copy text to clipboard', e));
+                }
+                catch (e) {
+                    console.error('Error accessing clipboard', e);
+                }
+            }
+        }
+        await this.sendViewContextUpdates(updates);
+        this.viewContextHasBeenSynced.next();
+    }
+    async startDownloadsFiles(downloads) {
+        for (const file of downloads) {
+            try {
+                let blob = await this.downloadResource(file.uuid, file.identifier);
+                let url = URL.createObjectURL(blob);
+                const link = document.createElement('a');
+                link.setAttribute('target', '_blank');
+                link.setAttribute('href', url);
+                link.setAttribute('download', file.filename);
+                document.body.appendChild(link);
+                link.click();
+                link.remove();
+            }
+            catch (e) {
+                console.error('Error downloading file', e);
+            }
+        }
+    }
+    setViewContextUuid(uuid) {
+        sessionStorage.setItem(this.viewContextUuidName, uuid);
+        this.session.addHeaderParam({
+            headerName: this.viewContextUuidHeaderName,
+            value: uuid,
+        });
+    }
+    getViewContextUuid() {
+        let viewContextUuid = sessionStorage.getItem(this.viewContextUuidName);
+        if (!viewContextUuid) {
+            throw new Error('View context is not initialized!');
+        }
+        return viewContextUuid;
+    }
+    hasViewContextUuid() {
+        let viewContextUuid = sessionStorage.getItem(this.viewContextUuidName);
+        return viewContextUuid !== null && viewContextUuid !== undefined;
+    }
+    setUuidOfPage(pageName, uuid, componentName) {
+        sessionStorage.setItem(this.pageNamePrefix + pageName, uuid);
+        if (componentName) {
+            sessionStorage.setItem(this.componentNamePrefix + componentName, pageName);
+        }
+    }
+    clearUuidOfPage(pageName, componentName) {
+        sessionStorage.removeItem(this.pageNamePrefix + pageName);
+        if (componentName) {
+            sessionStorage.removeItem(this.componentNamePrefix + componentName);
+        }
+    }
+    getUuidOfPage(pageName) {
+        let uuid = sessionStorage.getItem(this.pageNamePrefix + pageName);
+        if (!uuid) {
+            throw new Error(`The uuid of ${pageName} is not available.`);
+        }
+        return uuid;
+    }
+    getPageNameOfComponent(componentName) {
+        let pageName = sessionStorage.getItem(this.componentNamePrefix + componentName);
+        if (!pageName) {
+            throw new Error(`The pageName of ${componentName} is not available.`);
+        }
+        return pageName;
+    }
+    async message(messageData, messageResult) {
+        return await this.handlePerformActionResponse(await this.view
+            .message(messageData.viewUuid ?? '', messageData.uuid, messageResult)
+            .toPromise());
+        // in future use this.apiQueueService.addToQueue
+    }
+    async getSmartViewContextApiErrorByCode(code) {
+        let buttonLabel;
+        let dialogTitle;
+        let message;
+        if (this.translateService) {
+            buttonLabel = await this.translateService
+                .get(SmartViewContextErrorDialogButtonLabel)
+                .toPromise();
+            dialogTitle = await this.translateService.get(SmartViewContextErrorDialogTitle).toPromise();
+            message = await this.translateService.get(SmartViewContextErrorDialogMessage).toPromise();
+        }
+        else {
+            buttonLabel = 'Ok';
+            dialogTitle = 'Hiba';
+            message = 'An error has occured.';
+        }
+        if (!this.smartViewContextApiErrors) {
+            return {
+                code,
+                message,
+                buttonLabel,
+                dialogTitle,
+            };
+        }
+        let apiErrorsWithCode = this.smartViewContextApiErrors.viewContextApiErrors.filter((apiError) => {
+            return apiError.code === code;
+        });
+        if (!apiErrorsWithCode || (apiErrorsWithCode && !apiErrorsWithCode.length)) {
+            console.error(`SmartViewContextApiError with code ${code} could not be found.`);
+            return {
+                code,
+                message,
+                buttonLabel,
+                dialogTitle,
+            };
+        }
+        return apiErrorsWithCode[0];
+    }
+    async getViewConstraint(uuid) {
+        let viewConstraintResponse = await this.view.getViewConstraint(uuid).toPromise();
+        if (!viewConstraintResponse)
+            throw new Error('Could not get ViewConstraint with the given uuid.');
+        return viewConstraintResponse;
+    }
+    async showPublishedView(channel, uuid) {
+        this.isOpeningSmartLink = true;
+        await this.session.initialize();
+        // TODO init view context automatically
+        // await this.initialize();
+        await this.initViewContext();
+        this.openSmartLink.next(channel);
+        await this.openSmartLink.toPromise();
+        await this.view.showPublishedView(channel, uuid).toPromise();
+        await this.getAndSyncViewContext();
+        this.isOpeningSmartLink = false;
+    }
+    async downloadResource(uuid, item) {
+        return await this.view.downloadItem(uuid, item).toPromise();
+    }
+    async performAction(uuid, uiActionRequest) {
+        return await this._performAction({
+            uuid,
+            uiActionRequest,
+        });
+        // const isCompleted = new Subject<void>();
+        // this.apiQueueService.addToQueue({
+        //   callback: this._performAction.bind(this),
+        //   config: {
+        //     uuid,
+        //     uiActionRequest,
+        //   },
+        //   isCompleted,
+        // });
+        // return await isCompleted.toPromise();
+    }
+    async performWidgetAction(uuid, widgetId, nodeId, uiActionRequest) {
+        return await this._performWidgetAction({ uuid, widgetId, nodeId, uiActionRequest });
+        // const isCompleted = new Subject<void>();
+        // this.apiQueueService.addToQueue({
+        //   callback: this._performWidgetAction.bind(this),
+        //   config: {
+        //     uuid,
+        //     widgetId,
+        //     nodeId,
+        //     uiActionRequest,
+        //   },
+        //   isCompleted,
+        // });
+        // return await isCompleted.toPromise();
+    }
+    async performWidgetMainAction(uuid, widgetId, uiActionRequest) {
+        return await this._performWidgetMainAction({ uuid, widgetId, uiActionRequest });
+        // const isCompleted = new Subject<void>();
+        // this.apiQueueService.addToQueue({
+        //   callback: this._performWidgetMainAction.bind(this),
+        //   config: {
+        //     uuid,
+        //     widgetId,
+        //     uiActionRequest,
+        //   },
+        //   isCompleted,
+        // });
+        // return await isCompleted.toPromise();
+    }
+    async performUploadAction(uuid, uiActionRequest, param, content) {
+        this._performUploadAction({
+            uuid,
+            uiActionRequest,
+            param,
+            content,
+        });
+    }
+    async performUploadMultipleAction(uuid, uiActionRequest, param, content) {
+        this._performUploadMultipleAction({
+            uuid,
+            uiActionRequest,
+            param,
+            content,
+        });
+    }
+    async dataChanged(uuid, dataChange) {
+        return await this._dataChanged({ uuid, dataChange });
+        // const isCompleted = new Subject<void>();
+        // this.apiQueueService.addToQueue(
+        //   {
+        //     callback: this._dataChanged.bind(this),
+        //     config: {
+        //       uuid,
+        //       dataChange,
+        //     },
+        //     isCompleted,
+        //   },
+        //   true
+        // );
+        // return await isCompleted.toPromise();
+    }
+    async _performAction(config) {
+        return await this.handlePerformActionResponse(await this.view.performAction(config.uuid, config.uiActionRequest).toPromise());
+    }
+    async _performWidgetAction(config) {
+        return await this.handlePerformActionResponse(await this.view
+            .performWidgetAction(config.uuid, config.widgetId, config.nodeId, config.uiActionRequest)
+            .toPromise());
+    }
+    async _performWidgetMainAction(config) {
+        return await this.handlePerformActionResponse(await this.view
+            .performWidgetMainAction(config.uuid, config.widgetId, config.uiActionRequest)
+            .toPromise());
+    }
+    async _performUploadAction(config) {
+        return await this.handlePerformActionResponse(await this.view
+            .uploadAction(config.uuid, JSON.stringify(config.uiActionRequest), config.param, config.content)
+            .toPromise());
+    }
+    async _performUploadMultipleAction(config) {
+        return await this.handlePerformActionResponse(await this.view
+            .uploadMultipleAction(config.uuid, JSON.stringify(config.uiActionRequest), config.param, config.content)
+            .toPromise());
+    }
+    async _dataChanged(config) {
+        return await this.handlePerformActionResponse(await this.view.dataChanged(config.uuid, config.dataChange).toPromise());
+    }
+    async handlePerformActionResponse(viewContextChange) {
+        this.viewContext = viewContextChange?.viewContext;
+        await this.syncView();
+        if (viewContextChange?.changes) {
+            this.handleChanges(viewContextChange.changes);
+        }
+        return viewContextChange?.result;
+    }
+    handleChanges(changes) {
+        changes.forEach((componentModelChange) => {
+            let detectChange = this.smartApiClients.get(componentModelChange.uuid);
+            if (detectChange) {
+                detectChange.next(componentModelChange);
+            }
+        });
+    }
+    async load(uuid) {
+        return await this.view.getComponentModel(uuid).toPromise();
+    }
+    async load2(uuid) {
+        let change = await this.view.getComponentModel2(uuid).toPromise();
+        this.handlePerformActionResponse(change);
+        return change;
+    }
+    getCurrentViewContext() {
+        return this.viewContext;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartViewContextService, deps: [{ token: i1.ViewService }, { token: i2.SmartSessionService }, { token: i3.SmartViewContextDialogService }, { token: ApiQueueService }, { token: i0.Injector }, { token: COMPONENT_LIBRARY, optional: true }, { token: SMART_DEFAULT_VIEW_COMPONENTS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartViewContextService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartViewContextService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ViewService }, { type: i2.SmartSessionService }, { type: i3.SmartViewContextDialogService }, { type: ApiQueueService }, { type: i0.Injector }, { type: i4.ComponentLibrary, decorators: [{
+                    type: Inject,
+                    args: [COMPONENT_LIBRARY]
+                }, {
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [SMART_DEFAULT_VIEW_COMPONENTS]
+                }, {
+                    type: Optional
+                }] }] });
+export const IS_ASYNC_PARAM_NAME = 'isAsync';
+export class ApiQueueService {
+    constructor() {
+        this._destroy$ = new Subject();
+        this.queue = [];
+        this.isProcessing = false;
+        this.queueSubject = new SmartSubject(this._destroy$);
+        this.queueSubject.pipe(takeUntil(this._destroy$)).subscribe(() => this.processQueue());
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    addToQueue(call, priority = false) {
+        if (priority) {
+            this.queue.unshift(call); // Add at the beginning of the queue if it has higher priority
+        }
+        else {
+            this.queue.push(call); // Add at the end of the queue if it has lower priority
+        }
+        if (!this.isProcessing) {
+            this.processQueue();
+        }
+    }
+    async processQueue() {
+        if (this.queue.length === 0) {
+            this.isProcessing = false;
+            return;
+        }
+        const apiQueueCall = this.queue.shift();
+        if (apiQueueCall) {
+            await apiQueueCall.callback(apiQueueCall.config);
+            apiQueueCall.isCompleted.complete();
+            this.queueSubject.next();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: ApiQueueService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: ApiQueueService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: ApiQueueService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-view-context.service.js","sourceRoot":"","sources":["../../../../../projects/smart-ng-client/src/lib/view-context/smart-view-context.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Inject,\n  Injectable,\n  InjectionToken,\n  Injector,\n  model,\n  OnDestroy,\n  Optional,\n  ViewContainerRef,\n} from '@angular/core';\nimport { Subject, takeUntil } from 'rxjs';\nimport { SmartFormInvalidFields } from '../smart-form/smartform.model';\nimport { SmartSessionService } from '../session/smart-session.service';\nimport {\n  ClipboardData,\n  ComponentModel,\n  ComponentModelChange,\n  DataChange,\n  DownloadedFile,\n  Link,\n  LinkTargetEnum,\n  MessageData,\n  MessageResult,\n  UiActionDescriptor,\n  UiActionRequest,\n  ViewConstraint,\n  ViewContextChange,\n  ViewContextData,\n  ViewContextUpdate,\n  ViewData,\n  ViewService,\n  ViewState,\n  ViewStateUpdate,\n  ViewType,\n} from './api';\nimport { MessageDialogComponent } from './message-dialog/message-dialog.component';\nimport {\n  SmartEmbeddedViewRef,\n  SmartTranslateService,\n  SmartViewContextApiError,\n  SmartViewContextApiErrors,\n  SmartViewDialogRef,\n  SmartViewHandlerModel,\n} from './smart-view-context.model';\nimport { SmartSubject } from '../smart-subject/projects';\nimport { SmartViewContextDialogService } from './smart-view-context-dialog.service';\nimport { MatDialogRef } from '@angular/material/dialog';\nimport { DynamicDialogRef } from 'primeng/dynamicdialog';\nimport { COMPONENT_LIBRARY, ComponentLibrary } from './utility/componentLibrary';\nimport { ComponentType } from '@angular/cdk/portal';\nimport { resolveSlot, SlotKind } from './view-slot-resolution';\nimport {\n  SMART_DEFAULT_VIEW_COMPONENTS,\n  DefaultViewComponentEntry,\n} from './default-view-components.token';\nimport { resolveViewHandler } from './view-handler-resolution';\nimport { buildViewOps } from './view-op';\nimport { REUSE_ROUTER_SLOT_COMPONENT } from './reuse-router-slot.token';\n\nexport const SmartViewContextErrorDialogButtonLabel = 'SmartViewContextErrorDialogButtonLabel';\nexport const SmartViewContextErrorDialogTitle = 'SmartViewContextErrorDialogTitle';\nexport const SmartViewContextErrorDialogMessage = 'SmartViewContextErrorDialogMessage';\nexport const DefaultUiActionCode_CLOSE = 'DEFAULT_CLOSE';\n\nexport const DIALOG_DISABLE_CLOSE = new InjectionToken<boolean>('dialogDisableClose');\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SmartViewContextService implements OnDestroy {\n  private readonly viewContextUuidName: string = 'viewContextUuid';\n  private readonly viewContextUuidHeaderName: string = 'viewContextUuid';\n  private readonly pageNamePrefix: string = 'page.';\n  private readonly componentNamePrefix: string = 'component.';\n  public messageDialogname: string | undefined;\n  private url?: string;\n  private viewContext?: ViewContextData;\n  private viewHandlers: Array<SmartViewHandlerModel> = new Array();\n  private defaultComponents: Map<string, ComponentType<any>> = new Map();\n  private openedViewUuids: Array<string> = new Array();\n  private openedViewData: Array<ViewData> = new Array();\n  // Monotonic counter bumped on every successful startViewContext(). Callers\n  // that hold a reference to a view-uuid from a previous viewcontext can\n  // detect a rebuild by comparing snapshots of this value.\n  private generation: number = 0;\n\n  private _destroy$: Subject<void> = new Subject();\n  public uuidOfPageHasBeenChanged: Subject<string> = new SmartSubject(this._destroy$);\n  public viewContextHasBeenSynced: Subject<void> = new SmartSubject(this._destroy$);\n  private initializeRunning: Subject<ViewContextData> | undefined;\n  private initiNewContextRunning: Subject<void> | undefined;\n\n  public smartViewContextApiErrors?: SmartViewContextApiErrors;\n\n  public openSmartLink: Subject<string> = new SmartSubject(this._destroy$);\n  public isOpeningSmartLink: boolean = false;\n\n  private dialogRefs: SmartViewDialogRef[] = [];\n\n  private embeddedContainers: Map<string, Map<string, EmbeddedSlotEntry>> = new Map();\n  private embeddedViewRefs: SmartEmbeddedViewRef[] = [];\n  private pendingEmbeddedViews: ViewData[] = [];\n\n  private actionDescriptors?: Map<string, UiActionDescriptor>;\n\n  private moduleUrlsByModule?: Map<string, string>;\n\n  public commonFeedbackText?: string;\n\n  public smartApiClients: Map<string, SmartSubject<any>> = new Map();\n\n  public set translateService(translateService: SmartTranslateService | undefined) {\n    this._translateService = translateService;\n    this.translateServiceChanged.next();\n    this.translateServiceChanged.complete();\n  }\n\n  public get translateService(): SmartTranslateService | undefined {\n    if (this._translateService) {\n      return this._translateService;\n    }\n    return undefined;\n  }\n\n  private _translateService?: SmartTranslateService;\n  public translateServiceChanged: Subject<void> = new SmartSubject(this._destroy$);\n\n  public componentLibrary: ComponentLibrary | undefined;\n\n  constructor(\n    private view: ViewService,\n    private session: SmartSessionService,\n    private dialog: SmartViewContextDialogService,\n    private apiQueueService: ApiQueueService,\n    private inject: Injector,\n    @Inject(COMPONENT_LIBRARY) @Optional() compLib?: ComponentLibrary,\n    @Inject(SMART_DEFAULT_VIEW_COMPONENTS)\n    @Optional()\n    defaultViewComponents?: DefaultViewComponentEntry[]\n  ) {\n    this.componentLibrary = compLib;\n    for (const entry of defaultViewComponents ?? []) {\n      this.defaultComponents.set(entry.componentName, entry.component);\n    }\n  }\n\n  ngOnDestroy(): void {\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  public follow(uuid: string, detectChange: SmartSubject<any>): void {\n    this.smartApiClients.set(uuid, detectChange);\n  }\n  public unfollow(uuid: string): void {\n    this.smartApiClients.delete(uuid);\n  }\n\n  registerEmbeddedSlot(\n    containerUuid: string,\n    containerId: string,\n    vcRef: ViewContainerRef,\n    kind: SlotKind\n  ): void {\n    let innerMap = this.embeddedContainers.get(containerUuid);\n    if (!innerMap) {\n      innerMap = new Map();\n      this.embeddedContainers.set(containerUuid, innerMap);\n    }\n    innerMap.set(containerId, { vcRef, kind });\n\n    // Reattach embedded views that were detached before layout re-render\n    const existing = this.embeddedViewRefs.filter(\n      (ref) => ref.containerUuid === containerUuid && ref.containerId === containerId\n    );\n    for (const ref of existing) {\n      if (!ref.componentRef.hostView.destroyed) {\n        vcRef.insert(ref.componentRef.hostView);\n      }\n    }\n\n    // Drain pending queue (match on the resolved slot, so router-slot NORMAL views match too)\n    const matches = (v: ViewData) => {\n      const s = resolveSlot(v);\n      return s.containerUuid === containerUuid && s.containerId === containerId;\n    };\n    const matching = this.pendingEmbeddedViews.filter(matches);\n    this.pendingEmbeddedViews = this.pendingEmbeddedViews.filter((v) => !matches(v));\n\n    if (matching.length > 0) {\n      const updates: (ViewStateUpdate | undefined)[] = matching.map((v) => this.openView(v));\n      this.sendViewContextUpdates(updates);\n    }\n  }\n\n  detachAllEmbeddedViews(containerUuid: string): void {\n    const children = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid);\n    for (const child of children) {\n      if (child.componentRef.hostView.destroyed) {\n        continue;\n      }\n      // Only detach views living in a re-rendering LAYOUT slot. A STABLE directive\n      // slot (router-outlet) lives outside the layout *ngFor and survives the parent\n      // re-render, so its child needs no detach protection — detaching it here is\n      // what produced the false-orphan destroy in multi-level NORMAL nesting\n      // (Home -> Main -> page): Main got swept up by Home's layout dance. (#28870)\n      const entry = this.embeddedContainers.get(containerUuid)?.get(child.containerId);\n      if (!entry || entry.kind === 'stable') {\n        continue;\n      }\n      const idx = entry.vcRef.indexOf(child.componentRef.hostView);\n      if (idx >= 0) {\n        entry.vcRef.detach(idx);\n      }\n    }\n  }\n\n  cleanupOrphanedEmbeddedViews(containerUuid: string): void {\n    const refs = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid);\n    const orphaned: SmartEmbeddedViewRef[] = [];\n    for (const ref of refs) {\n      if (ref.componentRef.hostView.destroyed) {\n        orphaned.push(ref);\n        continue;\n      }\n      const vcRef = this.getEmbeddedSlot(containerUuid, ref.containerId);\n      if (!vcRef) {\n        // The slot is truly gone (its layout host was torn down and not recreated):\n        // a real orphan to destroy. A LAYOUT slot that came back re-registers and\n        // reattaches its child (registerEmbeddedSlot); a STABLE slot is never detached\n        // in the first place. So a still-registered slot here always holds its view —\n        // no reattach branch is needed (that branch only ever patched the stable\n        // false-orphan, which detachAllEmbeddedViews no longer creates). (#28870)\n        orphaned.push(ref);\n        continue;\n      }\n    }\n    for (const ref of orphaned) {\n      if (!ref.componentRef.hostView.destroyed) {\n        ref.componentRef.destroy();\n      }\n      const idx = this.openedViewUuids.indexOf(ref.uuid);\n      if (idx >= 0) {\n        this.openedViewUuids.splice(idx, 1);\n        this.openedViewData.splice(idx, 1);\n      }\n    }\n    this.embeddedViewRefs = this.embeddedViewRefs.filter((ref) => !orphaned.includes(ref));\n  }\n\n  getCompositeModel(containerUuid: string): { [key: string]: any } {\n    const result: { [key: string]: any } = {};\n    const children = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid);\n    for (const child of children) {\n      result[child.uuid] = child.componentRef.instance.getModel();\n      Object.assign(result, this.getCompositeModel(child.uuid));\n    }\n    return result;\n  }\n\n  submitEmbeddedForms(containerUuid: string, validate: boolean): SmartFormInvalidFields {\n    const allInvalidKeys: string[] = [];\n    const allInvalidNames: string[] = [];\n    const children = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid);\n    for (const child of children) {\n      const instance = child.componentRef.instance;\n      instance.submitForm(validate);\n      if (validate) {\n        const invalid: SmartFormInvalidFields = instance.getInvalidFields();\n        allInvalidKeys.push(...invalid.invalidFieldKeys);\n        allInvalidNames.push(...invalid.invalidFieldNames);\n      }\n      const nested = this.submitEmbeddedForms(child.uuid, validate);\n      allInvalidKeys.push(...nested.invalidFieldKeys);\n      allInvalidNames.push(...nested.invalidFieldNames);\n    }\n    return { invalidFieldKeys: allInvalidKeys, invalidFieldNames: allInvalidNames };\n  }\n\n  unregisterEmbeddedSlot(containerUuid: string, containerId: string): void {\n    const innerMap = this.embeddedContainers.get(containerUuid);\n    if (innerMap) {\n      innerMap.delete(containerId);\n      if (innerMap.size === 0) {\n        this.embeddedContainers.delete(containerUuid);\n      }\n    }\n  }\n\n  private getEmbeddedSlot(\n    containerUuid: string,\n    containerId: string\n  ): ViewContainerRef | undefined {\n    return this.embeddedContainers.get(containerUuid)?.get(containerId)?.vcRef;\n  }\n\n  /**\n   * Create the view's component into its resolved slot. Returns false and queues\n   * the view if the slot is not registered yet (drained on registration).\n   */\n  private insertViewIntoSlot(view: ViewData, component: ComponentType<any>): boolean {\n    const { containerUuid, containerId } = resolveSlot(view);\n    const vcRef = this.getEmbeddedSlot(containerUuid, containerId);\n    if (!vcRef) {\n      // Slot not registered yet: queue the view and drain it when its slot registers\n      // (registerEmbeddedSlot). The synchronous detectChanges below renders a freshly\n      // mounted parent's template in the same syncView pass, so a parent -> child ->\n      // grandchild chain (Home -> Main -> page) registers every slot immediately and\n      // the queue drains within the pass — even when restoreViews opens a child before\n      // its parent. (#28870)\n      this.pendingEmbeddedViews.push(view);\n      return false;\n    }\n    const componentRef = vcRef.createComponent(component);\n    componentRef.instance.uuid = view.uuid;\n    this.embeddedViewRefs.push({ uuid: view.uuid, containerUuid, containerId, componentRef });\n    // Render the freshly created component synchronously so its own embedded-slot\n    // directives (the router-outlet slot of a nested NORMAL view) register their\n    // containers immediately. This lets a parent -> child -> grandchild chain\n    // (e.g. Home -> Main -> page) mount in a single synchronous syncView pass\n    // instead of depending on a change-detection tick firing between each level.\n    // Without it the child cannot resolve its slot, queues into\n    // pendingEmbeddedViews, and the drain races the async updateViewContext\n    // round-trips — intermittently leaving a parent OPENED in backend bookkeeping\n    // but never mounted on the client, so its slot child stays blank. (#28870)\n    componentRef.changeDetectorRef.detectChanges();\n    componentRef.instance.run();\n    return true;\n  }\n\n  public setActionDescriptors(actionDescriptors: Map<string, UiActionDescriptor>): void {\n    this.actionDescriptors = actionDescriptors;\n  }\n\n  public getActionDescriptors(): Map<string, UiActionDescriptor> | undefined {\n    if (!this.actionDescriptors) {\n      console.error('No action descriptors has been set to ViewContext.');\n    }\n    return this.actionDescriptors;\n  }\n\n  public setViewHandlers(viewHandlers: Array<SmartViewHandlerModel>): void {\n    this.viewHandlers = viewHandlers;\n  }\n\n  public setViewApiErrors(viewApiErrors: SmartViewContextApiErrors): void {\n    this.smartViewContextApiErrors = viewApiErrors;\n  }\n\n  public setMessageDialogName(messageDialogName: string): void {\n    this.messageDialogname = messageDialogName;\n    this.viewHandlers.push({\n      name: messageDialogName,\n      component: MessageDialogComponent,\n    });\n  }\n\n  private setUpUrlForViewService(): void {\n    this.view.configuration.basePath = this.url;\n  }\n\n  public getModuleURL(module: string): string {\n    if (!this.moduleUrlsByModule) {\n      throw new Error('ModulesMap does not exist.');\n    }\n    let moduleUrl = this.moduleUrlsByModule?.get(module);\n\n    if (!moduleUrl) {\n      throw new Error('ModuleUrl does not exist with the given module.');\n    }\n    return moduleUrl;\n  }\n\n  public setModuleURL(modules: Map<string, string>): void {\n    this.moduleUrlsByModule = modules;\n  }\n\n  public setUrl(url: string): void {\n    this.url = url + '/view';\n    this.setUpUrlForViewService();\n  }\n\n  public async getAndSyncViewContext(uuid?: string): Promise<void> {\n    if (!uuid) {\n      uuid = this.getViewContextUuid();\n    }\n    await this.getViewContext(uuid).then(async () => {\n      await this.syncView();\n    });\n  }\n\n  public async getViewContext(uuid: string): Promise<ViewContextData> {\n    this.viewContext = await this.view.getViewContext(uuid).toPromise();\n    if (!this.viewContext) {\n      throw new Error('ViewContext does not exist with the given uuid.');\n    }\n    return this.viewContext;\n  }\n\n  public async getViewContextDataByPageName(pageName: string): Promise<ViewData> {\n    if (!this.viewContext) {\n      await this.getViewContext(this.getViewContextUuid());\n    }\n    let pageUuid = this.getUuidOfPage(pageName);\n\n    let viewContextByPageName = this.viewContext?.views.find((view) => view.uuid === pageUuid);\n    if (!viewContextByPageName) {\n      throw new Error(`The ViewData of ${pageName} is not found!`);\n    }\n    return viewContextByPageName;\n  }\n\n  public async updateViewContext(\n    viewContextUpdate: ViewContextUpdate\n  ): Promise<ViewContextData | undefined> {\n    viewContextUpdate.deviceInfo ??= {\n      deviceId: 'id',\n      userAgent: navigator.userAgent,\n      parameters: new Map(),\n    };\n    viewContextUpdate.deviceInfo.componentLibrary = this.componentLibrary;\n\n    this.viewContext = await this.view.updateViewContext(viewContextUpdate).toPromise();\n\n    return this.viewContext;\n  }\n\n  private clearSessionStorage(): void {\n    sessionStorage.clear();\n    this.clearEmbeddedViews();\n    this.openedViewData = [];\n    this.openedViewUuids = [];\n  }\n\n  /**\n   * Tear down all slot-hosted view components on a viewContext reset (e.g. logout /\n   * viewcontext-lost). Without this the previous view tree stays mounted in the root\n   * slot and the new tree is appended alongside it. Destroying a parent cascades to\n   * its nested slot directives (which unregister their containers via ngOnDestroy),\n   * leaving only the host-owned root slot registered.\n   */\n  private clearEmbeddedViews(): void {\n    for (const ref of this.embeddedViewRefs) {\n      if (!ref.componentRef.hostView.destroyed) {\n        ref.componentRef.destroy();\n      }\n    }\n    this.embeddedViewRefs = [];\n    this.pendingEmbeddedViews = [];\n  }\n\n  public async startViewContext(): Promise<ViewContextData> {\n    this.clearSessionStorage();\n    this.session.addHeaderParam({\n      headerName: this.viewContextUuidHeaderName,\n      value: '',\n    });\n\n    let newViewContext: ViewContextData | undefined = await this.view\n      .createViewContext()\n      .toPromise();\n    if (!newViewContext) {\n      throw new Error('No ViewContext was created');\n    }\n    this.viewContext = newViewContext;\n    this.setViewContextUuid(newViewContext.uuid!);\n    this.generation++;\n\n    return this.viewContext;\n  }\n\n  public getGeneration(): number {\n    return this.generation;\n  }\n\n  public async initialize(uuid?: string): Promise<ViewContextData | undefined> {\n    if (this.initializeRunning) {\n      return this.initializeRunning.toPromise();\n    } else {\n      this.initializeRunning = new SmartSubject(this._destroy$);\n      try {\n        if (this.viewHandlers.length === 0) {\n          throw new Error(\n            \"There aren't any viewHandlers in SmartViewContextService! Provide some to use its functions.\"\n          );\n        }\n        if (!this.messageDialogname) {\n          throw new Error('The messageDialogName provided by the backend has not been set.');\n        }\n        if (uuid) {\n          this.setViewContextUuid(uuid);\n          try {\n            await this.getViewContext(uuid);\n          } catch (err) {\n            await this.startViewContext();\n          }\n        } else {\n          await this.startViewContext();\n        }\n\n        return this.viewContext!;\n      } finally {\n        this.initializeRunning.next(this.viewContext!);\n        this.initializeRunning.complete();\n        this.initializeRunning = undefined;\n      }\n    }\n  }\n\n  public async initViewContext(): Promise<void> {\n    let uuid;\n    try {\n      uuid = this.getViewContextUuid();\n    } catch (error) {\n      await this.initialize();\n      uuid = this.getViewContextUuid();\n    }\n    await this.initialize(uuid);\n    await this.restoreViews(uuid);\n    await this.getAndSyncViewContext();\n  }\n\n  /**\n   * Hydrates the view-context state from an already-existing UUID provided\n   * externally (e.g. by a native mobile shell via URL fragment). Unlike\n   * `initialize(uuid)`, this method does NOT fall back to creating a fresh\n   * viewContext if the backend rejects the UUID — the caller is expected to\n   * surface the failure (typically via the bootstrap's `onStartError` hook).\n   */\n  public async initFromExistingViewContext(uuid: string): Promise<void> {\n    this.setViewContextUuid(uuid);\n    await this.getViewContext(uuid);\n    await this.restoreViews(uuid);\n  }\n\n  public async initNewViewContext(): Promise<void> {\n    if (this.initiNewContextRunning) {\n      return this.initiNewContextRunning.toPromise();\n    }\n    this.initiNewContextRunning = new SmartSubject(this._destroy$);\n    try {\n      await this.startViewContext();\n      let uuid = this.getViewContextUuid();\n      await this.initialize(uuid);\n      await this.restoreViews(uuid);\n    } finally {\n      this.initiNewContextRunning.next();\n      this.initiNewContextRunning.complete();\n      this.initiNewContextRunning = undefined;\n    }\n  }\n\n  public openView(view: ViewData): ViewStateUpdate | undefined {\n    let alreadyOpened = this.openedViewUuids.some((uuid) => uuid === view.uuid);\n    if (alreadyOpened) return undefined;\n\n    const viewHandler = resolveViewHandler(this.viewHandlers, this.defaultComponents, view);\n\n    if (!viewHandler) {\n      throw new Error(\n        `SmartViewHandlerModel was not found by view name: ${view.viewName} (componentName: ${view.componentName})`\n      );\n    }\n    if (view.type === ViewType.DIALOG) {\n      if (!viewHandler.component) {\n        throw new Error(\n          `Component is undefined in SmartViewHandlerModel with name: ${view.viewName}`\n        );\n      }\n      let refIsAlradyAdded = this.dialogRefs.some(\n        (ref: SmartViewDialogRef) => ref.uuid === view.uuid\n      );\n      if (!refIsAlradyAdded) {\n        let dialogRef;\n        try {\n          this.openedViewUuids.push(view.uuid);\n          this.openedViewData.push(view);\n          this.setUuidOfPage(view.viewName, view.uuid, viewHandler.componentName);\n          dialogRef = this.dialog.openComponentAsDialog(\n            viewHandler.component,\n            viewHandler.name,\n            view.uuid\n          );\n        } finally {\n          const index = this.openedViewUuids.indexOf(view.uuid);\n          if (index >= 0) {\n            this.openedViewUuids.splice(index, 1);\n            this.openedViewData.splice(index, 1);\n            this.clearUuidOfPage(view.viewName, viewHandler.componentName);\n          }\n\n          this.setUuidOfPage(view.viewName, view.uuid, viewHandler.componentName);\n        }\n        let dialogDisableClose = true;\n        let isMessageDialog = view.viewName === this.messageDialogname;\n        if (!isMessageDialog) {\n          try {\n            dialogDisableClose = this.inject.get(DIALOG_DISABLE_CLOSE);\n          } catch {\n            console.error('Error during reading DIALOG_DISABLE_CLOSE');\n          }\n        }\n        if (dialogRef instanceof MatDialogRef) {\n          dialogRef.disableClose = dialogDisableClose;\n          // if (isMessageDialog) {\n          //   if (view.message?.options && view.message.options.length) {\n          //   }\n          // }\n          if (!dialogDisableClose) {\n            dialogRef\n              .afterClosed()\n              .pipe(takeUntil(this._destroy$))\n              .subscribe(() => {\n                this.performAction(view.uuid, { code: DefaultUiActionCode_CLOSE, params: {} });\n              });\n          }\n        } else if (dialogRef instanceof DynamicDialogRef) {\n          if (!dialogDisableClose) {\n            dialogRef.onDestroy.pipe(takeUntil(this._destroy$)).subscribe(() => {\n              this.performAction(view.uuid, { code: DefaultUiActionCode_CLOSE, params: {} });\n            });\n          }\n        }\n\n        this.dialogRefs.push({\n          uuid: view.uuid,\n          dialogRef,\n        });\n      }\n    } else if (view.type === ViewType.NORMAL) {\n      if (!viewHandler.component) {\n        throw new Error(`Component is undefined in SmartViewHandlerModel with name: ${view.viewName}`);\n      }\n      // COMPATIBILITY SHIM (#28870, intentional): some child services (SmarttreeGenericService,\n      // SmartFilterEditorService) and generic components (SearchPageComponent, GenericPageComponent)\n      // still resolve their view uuid via the pageName -> getUuidOfPage(sessionStorage) indirection\n      // in their CONSTRUCTOR, which runs inside createComponent() below — before openView's normal\n      // bookkeeping. So the mapping must be written here, ahead of component creation. The proper\n      // fix (feed those consumers the injected uuid + defer their init) is deferred consumer plumbing;\n      // until then this write keeps the indirection correct in the slot world.\n      this.setUuidOfPage(view.viewName, view.uuid, viewHandler.componentName);\n      // A NORMAL view with no containerUuid lands in the host root slot (resolveSlot maps\n      // it to ROOT_CONTAINER_UUID); if no slot is registered yet it queues and drains later.\n      const inserted = this.insertViewIntoSlot(view, viewHandler.component);\n      if (!inserted) return undefined;\n    } else if (view.type === ViewType.EMBEDDED) {\n      if (!viewHandler.component) {\n        throw new Error(\n          `Component is undefined in SmartViewHandlerModel with name: ${view.viewName}`\n        );\n      }\n      // Write the page-uuid mapping ahead of component creation so constructor-time\n      // and nested getUuidOfPage(viewName) consumers (filter, tree) resolve. The\n      // page.<viewName> key is distinct per view, so it never collides. The\n      // component.<componentName> reverse key CAN be overwritten by another\n      // concurrent dynamic view of the same default component, but it is read only\n      // synchronously in the constructor (right after this write) and slot views\n      // load via the injected _uuid afterwards, so the overwrite never mis-resolves\n      // at runtime. (#28870)\n      this.setUuidOfPage(view.viewName, view.uuid, viewHandler.componentName);\n      const inserted = this.insertViewIntoSlot(view, viewHandler.component);\n      if (!inserted) return undefined;\n    } else {\n      throw new Error('The type of the view and its viewHandler is not the same!');\n    }\n\n    view.state = ViewState.OPENED;\n\n    this.openedViewUuids.push(view.uuid);\n    this.openedViewData.push(view);\n\n    if (view.type !== ViewType.EMBEDDED) {\n      this.setUuidOfPage(view.viewName, view.uuid, viewHandler.componentName);\n      this.uuidOfPageHasBeenChanged.next(view.viewName);\n    }\n\n    return {\n      state: ViewState.OPENED,\n      uuid: view.uuid,\n    };\n  }\n\n  public closeView(view: ViewData): ViewStateUpdate[] {\n    const viewHandler = resolveViewHandler(this.viewHandlers, this.defaultComponents, view);\n\n    if (!viewHandler) {\n      throw new Error(\n        `SmartViewHandlerModel was not found by view name: ${view.viewName} (componentName: ${view.componentName})`\n      );\n    }\n\n    const updates: ViewStateUpdate[] = [];\n\n    if (view.type === ViewType.DIALOG) {\n      let dialogRef = this.dialogRefs.find(\n        (dialogRef: SmartViewDialogRef) => dialogRef.uuid === view.uuid\n      );\n      if (dialogRef) {\n        dialogRef.dialogRef.close();\n        let index = this.dialogRefs.indexOf(dialogRef);\n        this.dialogRefs.splice(index, 1);\n      } else {\n        // console.log('DialogRef is not found by uuid.');\n      }\n      updates.push(...this.cleanupEmbeddedChildren(view.uuid));\n    } else if (view.type === ViewType.NORMAL) {\n      // Destroy nested children first, then the view's own slot component.\n      // destroyViewRef is a no-op for the legacy route-rendered (rootless) case.\n      updates.push(...this.cleanupEmbeddedChildren(view.uuid));\n      this.destroyViewRef(view.uuid);\n    } else if (view.type === ViewType.EMBEDDED) {\n      this.destroyViewRef(view.uuid);\n    } else {\n      throw new Error('The type of the view and its viewHandler is not the same!');\n    }\n\n    view.state = ViewState.CLOSED;\n\n    const index = this.openedViewUuids.indexOf(view.uuid);\n    if (index >= 0) {\n      this.openedViewUuids.splice(index, 1);\n      this.openedViewData.splice(index, 1);\n      // Clear for every type: openView now writes the page-uuid mapping for\n      // EMBEDDED views too (#28870), so the clear must be symmetric to avoid a\n      // stale sessionStorage entry. clearUuidOfPage is a no-op for keys never\n      // written, so this stays safe for the legacy rootless case.\n      this.clearUuidOfPage(view.viewName, viewHandler.componentName);\n    }\n\n    updates.push({\n      state: ViewState.CLOSED,\n      uuid: view.uuid,\n    });\n\n    return updates;\n  }\n\n  private cleanupEmbeddedChildren(containerUuid: string): ViewStateUpdate[] {\n    const updates: ViewStateUpdate[] = [];\n\n    const children = this.embeddedViewRefs.filter((ref) => ref.containerUuid === containerUuid);\n    for (const child of children) {\n      child.componentRef.destroy();\n      updates.push({ state: ViewState.CLOSED, uuid: child.uuid });\n    }\n    this.embeddedViewRefs = this.embeddedViewRefs.filter(\n      (ref) => ref.containerUuid !== containerUuid\n    );\n\n    this.pendingEmbeddedViews = this.pendingEmbeddedViews.filter(\n      (v) => v.containerUuid !== containerUuid\n    );\n\n    this.embeddedContainers.delete(containerUuid);\n\n    return updates;\n  }\n\n  /** Destroy the component for a view living in a slot, if present (no-op for route-rendered views). */\n  private destroyViewRef(uuid: string): void {\n    const refIndex = this.embeddedViewRefs.findIndex((ref) => ref.uuid === uuid);\n    if (refIndex >= 0) {\n      this.embeddedViewRefs[refIndex].componentRef.destroy();\n      this.embeddedViewRefs.splice(refIndex, 1);\n    }\n    this.pendingEmbeddedViews = this.pendingEmbeddedViews.filter((v) => v.uuid !== uuid);\n  }\n\n  private async sendViewContextUpdates(updatesToSend: (ViewStateUpdate | undefined)[]) {\n    const updates: ViewStateUpdate[] = [];\n    updatesToSend.forEach((update) => {\n      if (update !== undefined && update !== null) updates.push(update);\n    });\n    if (updates.length > 0) {\n      await this.updateViewContext({\n        updates,\n        uuid: this.viewContext?.uuid,\n      });\n    }\n  }\n  public async restoreViews(uuid: string): Promise<void> {\n    const updates: ViewStateUpdate[] = [];\n    if (!this.viewContext) {\n      await this.getViewContext(uuid);\n    }\n\n    this.viewContext!.views.filter(\n      (view) => view.state === ViewState.OPENED || view.state === ViewState.TO_OPEN\n    ).map((view: ViewData) => {\n      const update = this.openView(view);\n      if (update) {\n        updates.push(update);\n      }\n    });\n    await this.sendViewContextUpdates(updates);\n  }\n\n  private reuseEnabled(): boolean {\n    try {\n      const value = this.inject.get(REUSE_ROUTER_SLOT_COMPONENT);\n      return value !== false; // default ON when unset/null\n    } catch {\n      return true;\n    }\n  }\n\n  private executeReuse(oldView: ViewData, newView: ViewData): ViewStateUpdate[] {\n    const ref = this.embeddedViewRefs.find((r) => r.uuid === oldView.uuid);\n    if (!ref) {\n      // No live component to reuse (e.g. was route-rendered) — fall back to close + open.\n      const updates = [...this.closeView(oldView)];\n      const opened = this.openView(newView);\n      if (opened) updates.push(opened);\n      return updates;\n    }\n    // The reused parent is logically a fresh page (new uuid); its previous embedded\n    // children do not carry over (the backend leaves them keyed under the old parent\n    // uuid). Tear them down here and report them CLOSED.\n    const childUpdates = this.cleanupEmbeddedChildren(oldView.uuid);\n\n    ref.componentRef.instance.uuid = newView.uuid; // setter runs unfollow(old)/follow(new)\n    ref.uuid = newView.uuid;\n\n    const oldIdx = this.openedViewUuids.indexOf(oldView.uuid);\n    if (oldIdx >= 0) {\n      this.openedViewUuids.splice(oldIdx, 1);\n      this.openedViewData.splice(oldIdx, 1);\n    }\n    this.openedViewUuids.push(newView.uuid);\n    this.openedViewData.push(newView);\n\n    ref.componentRef.instance.run();\n\n    oldView.state = ViewState.CLOSED;\n    newView.state = ViewState.OPENED;\n\n    // Mirror the normal openView tail so getUuidOfPage consumers (e.g. trees) resolve the new uuid.\n    const viewHandler = resolveViewHandler(this.viewHandlers, this.defaultComponents, newView);\n    this.setUuidOfPage(newView.viewName, newView.uuid, viewHandler?.componentName);\n    this.uuidOfPageHasBeenChanged.next(newView.viewName);\n\n    return [\n      ...childUpdates,\n      { state: ViewState.CLOSED, uuid: oldView.uuid },\n      { state: ViewState.OPENED, uuid: newView.uuid },\n    ];\n  }\n\n  public async syncView(): Promise<void> {\n    const updates: (ViewStateUpdate | undefined)[] = [];\n    const ops = buildViewOps(this.viewContext?.views ?? [], this.reuseEnabled());\n    for (const op of ops) {\n      if (op.kind === 'open') {\n        updates.push(this.openView(op.view));\n      } else if (op.kind === 'close') {\n        updates.push(...this.closeView(op.view));\n      } else {\n        updates.push(...this.executeReuse(op.oldView, op.newView));\n      }\n    }\n\n    const viewDataToClose = this.openedViewData.filter(\n      (viewData: ViewData) =>\n        !this.viewContext?.views\n          .flatMap((viewData: ViewData) => viewData.uuid)\n          .includes(viewData.uuid)\n    );\n    if (viewDataToClose?.length) {\n      viewDataToClose.map((viewData: ViewData) => {\n        updates.push(...this.closeView(viewData));\n      });\n    }\n\n    this.viewContext?.links?.map((data: Link) => {\n      const link = document.createElement('a');\n      let target = '_blank'; // default\n      switch (data.target ?? LinkTargetEnum.BLANK) {\n        case 'SELF':\n          target = '_self';\n          break;\n        case 'BLANK':\n          target = '_blank';\n          break;\n        case 'PARENT':\n          target = '_parent';\n          break;\n        case 'TOP':\n          target = '_top';\n          break;\n      }\n      link.setAttribute('target', target);\n      link.setAttribute('href', data.url);\n      if (data.download) {\n        link.setAttribute('download', data.filename ?? '');\n      }\n      document.body.appendChild(link);\n      link.click();\n      link.remove();\n    });\n\n    this.startDownloadsFiles(this.viewContext?.downloads || []);\n\n    const clipboardText = this.viewContext?.clipboardData\n      ?.map((cd: ClipboardData) => cd.text || '')\n      .join('');\n    if (clipboardText) {\n      const clipboard = navigator.clipboard;\n      // available only in secure contexts.\n      if (clipboard) {\n        try {\n          clipboard\n            .writeText(clipboardText)\n            .catch((e) => console.error('Failed to copy text to clipboard', e));\n        } catch (e) {\n          console.error('Error accessing clipboard', e);\n        }\n      }\n    }\n    await this.sendViewContextUpdates(updates);\n    this.viewContextHasBeenSynced.next();\n  }\n\n  async startDownloadsFiles(downloads: DownloadedFile[]) {\n    for (const file of downloads) {\n      try {\n        let blob = await this.downloadResource(file.uuid!, file.identifier!);\n        let url = URL.createObjectURL(blob);\n\n        const link = document.createElement('a');\n        link.setAttribute('target', '_blank');\n        link.setAttribute('href', url);\n        link.setAttribute('download', file.filename!);\n        document.body.appendChild(link);\n        link.click();\n        link.remove();\n      } catch (e) {\n        console.error('Error downloading file', e);\n      }\n    }\n  }\n\n  private setViewContextUuid(uuid: string): void {\n    sessionStorage.setItem(this.viewContextUuidName, uuid);\n    this.session.addHeaderParam({\n      headerName: this.viewContextUuidHeaderName,\n      value: uuid,\n    });\n  }\n\n  public getViewContextUuid(): string {\n    let viewContextUuid = sessionStorage.getItem(this.viewContextUuidName);\n    if (!viewContextUuid) {\n      throw new Error('View context is not initialized!');\n    }\n    return viewContextUuid;\n  }\n\n  public hasViewContextUuid(): boolean {\n    let viewContextUuid = sessionStorage.getItem(this.viewContextUuidName);\n    return viewContextUuid !== null && viewContextUuid !== undefined;\n  }\n\n  public setUuidOfPage(pageName: string, uuid: string, componentName?: string): void {\n    sessionStorage.setItem(this.pageNamePrefix + pageName, uuid);\n    if (componentName) {\n      sessionStorage.setItem(this.componentNamePrefix + componentName, pageName);\n    }\n  }\n\n  public clearUuidOfPage(pageName: string, componentName?: string): void {\n    sessionStorage.removeItem(this.pageNamePrefix + pageName);\n    if (componentName) {\n      sessionStorage.removeItem(this.componentNamePrefix + componentName);\n    }\n  }\n\n  public getUuidOfPage(pageName: string): string {\n    let uuid = sessionStorage.getItem(this.pageNamePrefix + pageName);\n    if (!uuid) {\n      throw new Error(`The uuid of ${pageName} is not available.`);\n    }\n    return uuid;\n  }\n\n  public getPageNameOfComponent(componentName: string): string {\n    let pageName = sessionStorage.getItem(this.componentNamePrefix + componentName);\n    if (!pageName) {\n      throw new Error(`The pageName of ${componentName} is not available.`);\n    }\n    return pageName;\n  }\n\n  public async message(messageData: MessageData, messageResult: MessageResult): Promise<void> {\n    return await this.handlePerformActionResponse(\n      await this.view\n        .message(messageData.viewUuid ?? '', messageData.uuid, messageResult)\n        .toPromise()\n    );\n    // in future use this.apiQueueService.addToQueue\n  }\n\n  public async getSmartViewContextApiErrorByCode(code: string): Promise<SmartViewContextApiError> {\n    let buttonLabel;\n    let dialogTitle;\n    let message;\n    if (this.translateService) {\n      buttonLabel = await this.translateService\n        .get(SmartViewContextErrorDialogButtonLabel)\n        .toPromise();\n      dialogTitle = await this.translateService.get(SmartViewContextErrorDialogTitle).toPromise();\n      message = await this.translateService.get(SmartViewContextErrorDialogMessage).toPromise();\n    } else {\n      buttonLabel = 'Ok';\n      dialogTitle = 'Hiba';\n      message = 'An error has occured.';\n    }\n\n    if (!this.smartViewContextApiErrors) {\n      return {\n        code,\n        message,\n        buttonLabel,\n        dialogTitle,\n      };\n    }\n    let apiErrorsWithCode = this.smartViewContextApiErrors.viewContextApiErrors.filter(\n      (apiError: SmartViewContextApiError) => {\n        return apiError.code === code;\n      }\n    );\n    if (!apiErrorsWithCode || (apiErrorsWithCode && !apiErrorsWithCode.length)) {\n      console.error(`SmartViewContextApiError with code ${code} could not be found.`);\n\n      return {\n        code,\n        message,\n        buttonLabel,\n        dialogTitle,\n      };\n    }\n    return apiErrorsWithCode[0];\n  }\n\n  public async getViewConstraint(uuid: string): Promise<ViewConstraint> {\n    let viewConstraintResponse = await this.view.getViewConstraint(uuid).toPromise();\n    if (!viewConstraintResponse)\n      throw new Error('Could not get ViewConstraint with the given uuid.');\n    return viewConstraintResponse;\n  }\n\n  public async showPublishedView(channel: string, uuid: string): Promise<void> {\n    this.isOpeningSmartLink = true;\n\n    await this.session.initialize();\n    // TODO init view context automatically\n    // await this.initialize();\n    await this.initViewContext();\n\n    this.openSmartLink.next(channel);\n    await this.openSmartLink.toPromise();\n\n    await this.view.showPublishedView(channel, uuid).toPromise();\n    await this.getAndSyncViewContext();\n    this.isOpeningSmartLink = false;\n  }\n\n  public async downloadResource(uuid: string, item: string): Promise<any> {\n    return await this.view.downloadItem(uuid, item).toPromise();\n  }\n\n  public async performAction(uuid: string, uiActionRequest: UiActionRequest): Promise<void> {\n    return await this._performAction({\n      uuid,\n      uiActionRequest,\n    });\n    // const isCompleted = new Subject<void>();\n    // this.apiQueueService.addToQueue({\n    //   callback: this._performAction.bind(this),\n    //   config: {\n    //     uuid,\n    //     uiActionRequest,\n    //   },\n    //   isCompleted,\n    // });\n    // return await isCompleted.toPromise();\n  }\n\n  public async performWidgetAction(\n    uuid: string,\n    widgetId: string,\n    nodeId: string,\n    uiActionRequest: UiActionRequest\n  ): Promise<void> {\n    return await this._performWidgetAction({ uuid, widgetId, nodeId, uiActionRequest });\n    // const isCompleted = new Subject<void>();\n    // this.apiQueueService.addToQueue({\n    //   callback: this._performWidgetAction.bind(this),\n    //   config: {\n    //     uuid,\n    //     widgetId,\n    //     nodeId,\n    //     uiActionRequest,\n    //   },\n    //   isCompleted,\n    // });\n    // return await isCompleted.toPromise();\n  }\n\n  public async performWidgetMainAction(\n    uuid: string,\n    widgetId: string,\n    uiActionRequest: UiActionRequest\n  ): Promise<void> {\n    return await this._performWidgetMainAction({ uuid, widgetId, uiActionRequest });\n    // const isCompleted = new Subject<void>();\n    // this.apiQueueService.addToQueue({\n    //   callback: this._performWidgetMainAction.bind(this),\n    //   config: {\n    //     uuid,\n    //     widgetId,\n    //     uiActionRequest,\n    //   },\n    //   isCompleted,\n    // });\n    // return await isCompleted.toPromise();\n  }\n\n  public async performUploadAction(\n    uuid: string,\n    uiActionRequest: UiActionRequest,\n    param: 'input' | 'input\"',\n    content: any\n  ): Promise<void> {\n    this._performUploadAction({\n      uuid,\n      uiActionRequest,\n      param,\n      content,\n    });\n  }\n\n  public async performUploadMultipleAction(\n    uuid: string,\n    uiActionRequest: UiActionRequest,\n    param: 'input' | 'input2',\n    content: any[]\n  ): Promise<void> {\n    this._performUploadMultipleAction({\n      uuid,\n      uiActionRequest,\n      param,\n      content,\n    });\n  }\n\n  public async dataChanged(uuid: string, dataChange: DataChange): Promise<void> {\n    return await this._dataChanged({ uuid, dataChange });\n    // const isCompleted = new Subject<void>();\n    // this.apiQueueService.addToQueue(\n    //   {\n    //     callback: this._dataChanged.bind(this),\n    //     config: {\n    //       uuid,\n    //       dataChange,\n    //     },\n    //     isCompleted,\n    //   },\n    //   true\n    // );\n    // return await isCompleted.toPromise();\n  }\n\n  private async _performAction(config: any): Promise<void> {\n    return await this.handlePerformActionResponse(\n      await this.view.performAction(config.uuid, config.uiActionRequest).toPromise()\n    );\n  }\n\n  private async _performWidgetAction(config: any): Promise<void> {\n    return await this.handlePerformActionResponse(\n      await this.view\n        .performWidgetAction(config.uuid, config.widgetId, config.nodeId, config.uiActionRequest)\n        .toPromise()\n    );\n  }\n\n  private async _performWidgetMainAction(config: any): Promise<void> {\n    return await this.handlePerformActionResponse(\n      await this.view\n        .performWidgetMainAction(config.uuid, config.widgetId, config.uiActionRequest)\n        .toPromise()\n    );\n  }\n\n  private async _performUploadAction(config: any): Promise<void> {\n    return await this.handlePerformActionResponse(\n      await this.view\n        .uploadAction(\n          config.uuid,\n          JSON.stringify(config.uiActionRequest),\n          config.param,\n          config.content\n        )\n        .toPromise()\n    );\n  }\n  private async _performUploadMultipleAction(config: any): Promise<void> {\n    return await this.handlePerformActionResponse(\n      await this.view\n        .uploadMultipleAction(\n          config.uuid,\n          JSON.stringify(config.uiActionRequest),\n          config.param,\n          config.content\n        )\n        .toPromise()\n    );\n  }\n\n  private async _dataChanged(config: any): Promise<any> {\n    return await this.handlePerformActionResponse(\n      await this.view.dataChanged(config.uuid, config.dataChange).toPromise()\n    );\n  }\n\n  public async handlePerformActionResponse(\n    viewContextChange: ViewContextChange | undefined\n  ): Promise<any> {\n    this.viewContext = viewContextChange?.viewContext;\n    await this.syncView();\n\n    if (viewContextChange?.changes) {\n      this.handleChanges(viewContextChange.changes);\n    }\n    return viewContextChange?.result;\n  }\n\n  private handleChanges(changes: Array<ComponentModelChange>): void {\n    changes.forEach((componentModelChange: ComponentModelChange) => {\n      let detectChange: SmartSubject<ComponentModelChange> | undefined = this.smartApiClients.get(\n        componentModelChange.uuid\n      );\n      if (detectChange) {\n        detectChange.next(componentModelChange);\n      }\n    });\n  }\n\n  public async load(uuid: string): Promise<ComponentModel | undefined> {\n    return await this.view.getComponentModel(uuid).toPromise();\n  }\n\n  public async load2(uuid: string): Promise<ViewContextChange | undefined> {\n    let change = await this.view.getComponentModel2(uuid).toPromise();\n    this.handlePerformActionResponse(change);\n    return change;\n  }\n\n  getCurrentViewContext(): ViewContextData | undefined {\n    return this.viewContext;\n  }\n}\n\nexport const IS_ASYNC_PARAM_NAME = 'isAsync';\n\n/** A registered embedded slot: its ViewContainerRef plus the lifecycle class its\n *  registrant declared, so the layout detach/cleanup dance can skip 'stable' slots. */\ninterface EmbeddedSlotEntry {\n  vcRef: ViewContainerRef;\n  kind: SlotKind;\n}\n\nexport interface ApiQueueCall {\n  callback: (config: any) => Promise<any>;\n  config: any;\n  isCompleted: Subject<void>;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ApiQueueService implements OnDestroy {\n  private _destroy$: Subject<void> = new Subject();\n\n  private queue: ApiQueueCall[] = [];\n  private isProcessing = false;\n  private queueSubject: Subject<void> = new SmartSubject(this._destroy$);\n\n  constructor() {\n    this.queueSubject.pipe(takeUntil(this._destroy$)).subscribe(() => this.processQueue());\n  }\n  ngOnDestroy(): void {\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  addToQueue(call: ApiQueueCall, priority: boolean = false) {\n    if (priority) {\n      this.queue.unshift(call); // Add at the beginning of the queue if it has higher priority\n    } else {\n      this.queue.push(call); // Add at the end of the queue if it has lower priority\n    }\n    if (!this.isProcessing) {\n      this.processQueue();\n    }\n  }\n\n  async processQueue(): Promise<void> {\n    if (this.queue.length === 0) {\n      this.isProcessing = false;\n      return;\n    }\n\n    const apiQueueCall = this.queue.shift();\n    if (apiQueueCall) {\n      await apiQueueCall.callback(apiQueueCall.config);\n      apiQueueCall.isCompleted.complete();\n      this.queueSubject.next();\n    }\n  }\n}\n"]}