@smartbit4all/ng-client 7.3.24 → 7.3.25

package/fesm2022/smartbit4all-ng-client.mjs

@@ -8,8 +8,8 @@ import { QuillEditorComponent, QuillModule } from 'ngx-quill';
 import { DateFnsAdapter } from '@angular/material-date-fns-adapter';
 import { enUS, hu } from 'date-fns/locale';
 import { isPlatformBrowser, NgClass, NgTemplateOutlet, NgStyle, Location, AsyncPipe, KeyValuePipe, DatePipe, NgIf, NgForOf } from '@angular/common';
-import { Subject, lastValueFrom, tap, takeUntil, interval, startWith, map, distinctUntilChanged, throwError, from, catchError as catchError$1 } from 'rxjs';
-import { catchError, switchMap, takeUntil as takeUntil$1 } from 'rxjs/operators';
+import { Subject, lastValueFrom, defer, finalize, filter, startWith, map, distinctUntilChanged, tap, takeUntil, interval, throwError, from, catchError as catchError$1 } from 'rxjs';
+import { catchError, switchMap, filter as filter$1, takeUntil as takeUntil$1 } from 'rxjs/operators';
 import { deepEqual } from 'fast-equals';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { MatDialogRef, MatDialog, MAT_DIALOG_DATA, MatDialogContent, MatDialogTitle, MatDialogClose, MatDialogActions } from '@angular/material/dialog';
@@ -23,7 +23,7 @@ import { MAT_SNACK_BAR_DATA, MatSnackBarLabel, MatSnackBar } from '@angular/mate
 import { Overlay, OverlayPositionBuilder, ScrollDispatcher } from '@angular/cdk/overlay';
 import { TemplatePortal } from '@angular/cdk/portal';
 import * as i1$1 from '@angular/forms';
-import { Validators, UntypedFormGroup, UntypedFormControl, NG_VALUE_ACCESSOR, FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { Validators, UntypedFormControl, UntypedFormGroup, NG_VALUE_ACCESSOR, FormsModule, ReactiveFormsModule } from '@angular/forms';
 import { ENTER, COMMA } from '@angular/cdk/keycodes';
 import { MatAutocompleteTrigger, MatAutocomplete } from '@angular/material/autocomplete';
 import { MatChipGrid, MatChipRow, MatChipRemove, MatChipInput, MatChip } from '@angular/material/chips';
@@ -56,6 +56,8 @@ import ZoomPlugin from 'chartjs-plugin-zoom';
 import ChartDataLabels from 'chartjs-plugin-datalabels';
 import { MatToolbar } from '@angular/material/toolbar';
 
+/** The default count limit of the Global Value Set Store's explicit sets. */
+const DEFAULT_VALUE_SET_STORE_SIZE = 200;
 /**
  * The resolved library configuration. Provided by {@link provideSmartNgClient}; inject it
  * to read a configured value.
@@ -68,6 +70,7 @@ function resolveSmartNgClientConfig(config) {
         treeMenuIcon: 'more_vert',
         dialogDisableClose: true,
         dateLocale: 'hu-HU',
+        valueSetStoreSize: DEFAULT_VALUE_SET_STORE_SIZE,
         ...config,
         // Merged field by field, so that configuring one string keeps the other two defaults.
         errorDialog: {
@@ -1609,6 +1612,60 @@ class ViewService {
             reportProgress: reportProgress
         });
     }
+    fetchValueSets(viewUuid, valueSetFetchRequest, observe = 'body', reportProgress = false, options) {
+        if (viewUuid === null || viewUuid === undefined) {
+            throw new Error('Required parameter viewUuid was null or undefined when calling fetchValueSets.');
+        }
+        if (valueSetFetchRequest === null || valueSetFetchRequest === undefined) {
+            throw new Error('Required parameter valueSetFetchRequest was null or undefined when calling fetchValueSets.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = [
+                'application/json'
+            ];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/component/${this.configuration.encodeParam({ name: "viewUuid", value: viewUuid, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: "uuid" })}/valueSets`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            body: valueSetFetchRequest,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
     getAndroidTheme(name, observe = 'body', reportProgress = false, options) {
         if (name === null || name === undefined) {
             throw new Error('Required parameter name was null or undefined when calling getAndroidTheme.');
@@ -3091,6 +3148,30 @@ var UploadWidgetType;
     UploadWidgetType["IMAGE"] = "IMAGE";
 })(UploadWidgetType || (UploadWidgetType = {}));
 
+/**
+ * View API
+ * View API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+/**
+ * View API
+ * View API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
 /**
  * View API
  * View API
@@ -4228,6 +4309,602 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImpor
             args: [{ selector: '[smartEmbeddedSlot]' }]
         }], propDecorators: { containerId: [{ type: i0.Input, args: [{ isSignal: true, alias: "smartEmbeddedSlot", required: true }] }], containerUuid: [{ type: i0.Input, args: [{ isSignal: true, alias: "containerUuid", required: false }] }] } });
 
+/**
+ * The key and display property of a valueSet's values: the preferred name if the values carry it,
+ * then the GenericValue name (`uri` / `name`), then the Value name (`objectUri` / `displayValue`).
+ * With no sample value to look at the preferred name is assumed to exist.
+ */
+function valueSetKeyProperty(values, preferred) {
+    return firstExisting(values, [preferred ?? 'objectUri', 'uri', 'objectUri']);
+}
+function valueSetDisplayProperty(values, preferred) {
+    return firstExisting(values, [preferred ?? 'displayValue', 'name', 'displayValue']);
+}
+/** The label of a code in a valueSet, or undefined when the valueSet does not know the code. */
+function valueSetLabelOf(valueSetData, code) {
+    const values = valueSetData.values ?? [];
+    const keyProperty = valueSetKeyProperty(values, valueSetData.keyProperty);
+    const hit = values.find((value) => String(value[keyProperty]) === String(code));
+    return hit?.[valueSetDisplayProperty(values)];
+}
+function firstExisting(values, candidates) {
+    if (!values?.length) {
+        return candidates[0];
+    }
+    return candidates.find((c) => c in values[0]) ?? candidates[candidates.length - 1];
+}
+
+/**
+ * The Global Value Set Store: the value sets of the browser tab shared by every open view,
+ * explicit sets by backend module, namespace and name, implicit sets by view uuid and key. It
+ * fetches the versions a view context change names and it lacks, keeps what the open views read
+ * and empties at a change of the session locale.
+ */
+class SmartValueSetStore {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SmartValueSetStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SmartValueSetStore, providedIn: "root", useFactory: () => new SmartValueSetMemoryStore() }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SmartValueSetStore, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                    useFactory: () => new SmartValueSetMemoryStore(),
+                }]
+        }] });
+class SmartValueSetMemoryStore extends SmartValueSetStore {
+    constructor() {
+        super();
+        this.viewService = inject(ViewService);
+        /** The view context service injects the store, so it is looked up at use. */
+        this.injector = inject(Injector);
+        this.sizeLimit = inject(SMART_NG_CLIENT_CONFIG).valueSetStoreSize;
+        this.changeSource = new Subject();
+        this.changes = this.changeSource.asObservable();
+        /** In the order of their last write, the least recently written first. */
+        this.explicitEntries = new Map();
+        /** The entries of each view by key. */
+        this.viewEntries = new Map();
+        /** The closed views the view context still lists; a late model write of one is not taken. */
+        this.closedViewUuids = new Set();
+        /** The selections the widgets of each open view read through, by the name of the set. */
+        this.viewSelections = new Map();
+        /** The keys of the explicit sets the `label` pipe of each open view read by name. */
+        this.readExplicitKeys = new Map();
+        /** The number of subscribers of {@link get} to each explicit set. */
+        this.subscriberCounts = new Map();
+        /** The version of each branch item of the version maps, by its explicit key. */
+        this.branchVersions = new Map();
+        /** The fetches of each entry, by its explicit or implicit key. */
+        this.fetchRecords = new Map();
+        /** Numbers the fetches in the order they start. */
+        this.fetchSequence = 0;
+        /** Stepped by {@link clear}; the answer of a fetch started before is dropped. */
+        this.epoch = 0;
+        /** The number of holds {@link holdFetches} gave out and not yet released. */
+        this.holdCount = 0;
+        /** The sets waiting for the next fetch, by backend module. */
+        this.pendingFetches = new Map();
+        // The sets are resolved in the session locale; the session reports it at every initialize.
+        const session = inject(SmartSessionService);
+        let locale = session.sessionInfoData?.locale;
+        session.localeChanged.subscribe(() => {
+            const previousLocale = locale;
+            locale = session.sessionInfoData?.locale;
+            if (previousLocale !== undefined && previousLocale !== locale) {
+                this.clear();
+            }
+        });
+    }
+    get(module, namespace, name) {
+        const key = createExplicitKey(module, namespace, name);
+        return defer(() => {
+            this.subscriberCounts.set(key, (this.subscriberCounts.get(key) ?? 0) + 1);
+            return this.followChanges(name, () => this.explicitEntries.get(key)?.data);
+        }).pipe(finalize(() => this.releaseSubscriber(key)));
+    }
+    getImplicit(viewUuid, key) {
+        return this.followChanges(key, () => {
+            const entry = this.viewEntries.get(viewUuid)?.get(key);
+            return entry?.implicit ? entry.data : undefined;
+        });
+    }
+    getForSelection(viewUuid, selection) {
+        return defer(() => {
+            this.registerSelection(viewUuid, selection);
+            return this.followChanges(selection.valueSetName, () => this.findForSelection(viewUuid, selection));
+        });
+    }
+    findByName(viewUuid, name) {
+        const module = this.findViewModule(viewUuid);
+        const selection = this.viewSelections.get(viewUuid)?.get(name) ?? {
+            valueSetNamespace: this.findLastWrittenNamespace(module, name),
+            valueSetName: name,
+        };
+        const data = this.findForSelection(viewUuid, selection);
+        if (data && !this.viewEntries.get(viewUuid)?.get(name)?.implicit) {
+            this.registerExplicitRead(viewUuid, createExplicitKey(module, selection.valueSetNamespace, name));
+        }
+        return data;
+    }
+    putImplicit(viewUuid, valueSets) {
+        if (this.closedViewUuids.has(viewUuid)) {
+            return;
+        }
+        let isFetchPending = false;
+        Object.entries(valueSets ?? {}).forEach(([key, valueSet]) => {
+            if (!valueSet) {
+                return;
+            }
+            const held = this.viewEntries.get(viewUuid)?.get(key);
+            const extras = {
+                extraValues: valueSet.extraValues,
+                excludedKeys: valueSet.excludedKeys,
+            };
+            // A version alone keeps the values held on screen until the fetch brings the new ones.
+            const next = !valueSet.valueSetData && valueSet.version && held?.implicit
+                ? { ...held, ...extras }
+                : {
+                    implicit: !!(valueSet.valueSetData || valueSet.version),
+                    version: valueSet.valueSetData ? valueSet.version : undefined,
+                    data: valueSet.valueSetData,
+                    ...extras,
+                };
+            if (!deepEqual(held, next)) {
+                this.writeViewEntry(viewUuid, key, next);
+            }
+            const entryKey = createImplicitKey(viewUuid, key);
+            if (!valueSet.valueSetData &&
+                valueSet.version &&
+                valueSet.version !== next.version &&
+                !this.isFetching(entryKey, valueSet.version)) {
+                this.markFetching(entryKey, valueSet.version);
+                this.queueImplicitItem(viewUuid, key);
+                isFetchPending = true;
+            }
+        });
+        if (isFetchPending) {
+            this.scheduleFlush().catch((err) => console.error("implicit value set fetch failed", err));
+        }
+    }
+    removeView(viewUuid) {
+        // Only the views the view context still lists are kept, so the set does not grow with the tab.
+        const listedViewUuids = new Set(this.injector
+            .get(SmartViewContextService)
+            .getCurrentViewContext()
+            ?.views?.map((view) => view.uuid));
+        this.closedViewUuids.forEach((uuid) => {
+            if (!listedViewUuids.has(uuid)) {
+                this.closedViewUuids.delete(uuid);
+            }
+        });
+        this.closedViewUuids.add(viewUuid);
+        this.viewSelections.delete(viewUuid);
+        this.readExplicitKeys.delete(viewUuid);
+        this.pendingFetches.forEach((pending) => {
+            pending.items = pending.items.filter((item) => item.implicitViewUuid !== viewUuid);
+        });
+        const entries = this.viewEntries.get(viewUuid);
+        if (!entries) {
+            return;
+        }
+        this.viewEntries.delete(viewUuid);
+        entries.forEach((_, key) => {
+            this.fetchRecords.delete(createImplicitKey(viewUuid, key));
+            this.changeSource.next(key);
+        });
+    }
+    holdFetches() {
+        this.holdCount++;
+        return () => {
+            this.holdCount--;
+            if (!this.holdCount) {
+                this.flushFetches();
+            }
+        };
+    }
+    applyVersions(viewContextChange, viewUuid) {
+        const versions = viewContextChange?.valueSetVersions;
+        const requestViewUuid = viewUuid ?? viewContextChange?.changes?.[0]?.uuid;
+        if (!versions?.length || !requestViewUuid) {
+            return Promise.resolve();
+        }
+        const module = this.findViewModule(requestViewUuid);
+        const readKeys = this.collectReadExplicitKeys();
+        let isFetchPending = false;
+        /** The version noted before and the one noted now of each branch item queued for a fetch. */
+        const notedBranchVersions = new Map();
+        versions.forEach((version) => {
+            const key = createExplicitKey(module, version.namespace, version.name, version.branchUri);
+            if (version.branchUri) {
+                const previous = this.branchVersions.get(key);
+                this.branchVersions.set(key, version.version);
+                if (previous === undefined || previous === version.version) {
+                    return;
+                }
+                const holders = this.findViewsHoldingImplicitly(module, version.name);
+                if (!holders.length) {
+                    return;
+                }
+                holders.forEach((holder) => this.queueImplicitItem(holder, version.name));
+                notedBranchVersions.set(key, [previous, version.version]);
+                isFetchPending = true;
+                return;
+            }
+            const held = this.explicitEntries.get(key)?.version;
+            if (held === version.version ||
+                this.isFetching(key, version.version) ||
+                this.isHeldOnlyImplicitly(module, key, version.name, readKeys)) {
+                return;
+            }
+            this.markFetching(key, version.version);
+            this.queueItem(module, requestViewUuid, {
+                namespace: version.namespace,
+                name: version.name,
+                branchUri: version.branchUri,
+                version: held,
+            });
+            isFetchPending = true;
+        });
+        if (!isFetchPending) {
+            return Promise.resolve();
+        }
+        const flush = this.scheduleFlush();
+        // A branch version whose fetch failed is taken back, so the next map fetches again.
+        flush.catch(() => notedBranchVersions.forEach(([previous, noted], key) => {
+            if (this.branchVersions.get(key) === noted) {
+                this.branchVersions.set(key, previous);
+            }
+        }));
+        return flush;
+    }
+    fetch(module, viewUuid, items) {
+        if (!items.length) {
+            return Promise.resolve();
+        }
+        items.forEach((item) => this.queueItem(module ?? "", viewUuid, item));
+        return this.scheduleFlush();
+    }
+    clear() {
+        const readKeys = this.collectReadExplicitKeys();
+        const entries = [...this.explicitEntries];
+        this.explicitEntries.clear();
+        this.fetchRecords.clear();
+        this.epoch++;
+        // A set fetched again is marked in the version it had, so a change naming it asks nothing.
+        entries.forEach(([key, entry]) => {
+            const { module, namespace, name, branchUri } = parseExplicitKey(key);
+            if (readKeys.has(key)) {
+                this.markFetching(key, entry.version);
+                this.queueItem(module, entry.viewUuid, { namespace, name, branchUri });
+            }
+            this.changeSource.next(name);
+        });
+        this.viewEntries.forEach((entries, viewUuid) => entries.forEach((held, key) => {
+            if (held.implicit) {
+                this.markFetching(createImplicitKey(viewUuid, key), held.version);
+                this.writeViewEntry(viewUuid, key, { ...held, version: undefined, data: undefined });
+                this.queueImplicitItem(viewUuid, key);
+            }
+        }));
+        if (this.pendingFetches.size) {
+            this.scheduleFlush().catch((err) => console.error("value set fetch failed", err));
+        }
+    }
+    /** Queues the item for the fetch of the module, which goes through the first view queued. */
+    queueItem(module, viewUuid, item) {
+        const pending = this.pendingFetches.get(module) ?? { viewUuid, items: [] };
+        pending.items.push(item);
+        this.pendingFetches.set(module, pending);
+    }
+    queueImplicitItem(viewUuid, key) {
+        const module = this.findViewModule(viewUuid);
+        const isQueued = this.pendingFetches
+            .get(module)
+            ?.items.some((item) => item.implicitViewUuid === viewUuid && item.name === key);
+        if (!isQueued) {
+            this.queueItem(module, viewUuid, { name: key, implicitViewUuid: viewUuid });
+        }
+    }
+    /** The promise of the fetches waiting, sent now or when the last hold is released. */
+    scheduleFlush() {
+        if (!this.pendingFlush) {
+            let resolve;
+            let reject;
+            const promise = new Promise((res, rej) => {
+                resolve = res;
+                reject = rej;
+            });
+            this.pendingFlush = { promise, resolve, reject };
+        }
+        const promise = this.pendingFlush.promise;
+        if (!this.holdCount) {
+            this.flushFetches();
+        }
+        return promise;
+    }
+    /** Sends the items waiting, one Value Set Fetch per backend module. */
+    flushFetches() {
+        const flush = this.pendingFlush;
+        if (!flush) {
+            return;
+        }
+        this.pendingFlush = undefined;
+        const pendingFetches = [...this.pendingFetches];
+        this.pendingFetches = new Map();
+        Promise.all(pendingFetches.map(([module, pending]) => this.sendFetch(module, pending))).then(() => flush.resolve(), (err) => flush.reject(err));
+    }
+    /**
+     * One Value Set Fetch of a module through its view, each answer written to the set of its item.
+     * An implicit set asks with the version its view holds.
+     */
+    async sendFetch(module, pending) {
+        const epoch = this.epoch;
+        const sent = pending.items.map((item) => {
+            const entryKey = item.implicitViewUuid
+                ? createImplicitKey(item.implicitViewUuid, item.name)
+                : createExplicitKey(module, item.namespace, item.name, item.branchUri);
+            return {
+                item: item.implicitViewUuid
+                    ? {
+                        ...item,
+                        version: this.viewEntries.get(item.implicitViewUuid)?.get(item.name)?.version,
+                    }
+                    : item,
+                entryKey,
+                fetchingVersion: this.fetchRecords.get(entryKey)?.fetchingVersion,
+            };
+        });
+        try {
+            if (!sent.length) {
+                return;
+            }
+            const sequence = ++this.fetchSequence;
+            const response = await lastValueFrom(this.viewService.fetchValueSets(pending.viewUuid, { items: sent.map(({ item }) => item) }));
+            if (epoch !== this.epoch) {
+                return;
+            }
+            response?.items?.forEach((result, index) => {
+                const { item, entryKey } = sent[index];
+                if (item.implicitViewUuid) {
+                    this.writeImplicitResult(item.implicitViewUuid, item.name, result, sequence);
+                }
+                else {
+                    this.writeExplicitResult(entryKey, item.name, result, pending.viewUuid, sequence);
+                }
+            });
+            this.evictExplicitEntries();
+        }
+        finally {
+            // A later change may start a newer fetch of an entry meanwhile; only this one's mark ends.
+            sent.forEach(({ entryKey, fetchingVersion }) => {
+                const record = this.fetchRecords.get(entryKey);
+                const isMarkOfThisFetch = fetchingVersion && record?.fetchingVersion === fetchingVersion;
+                if (epoch === this.epoch && isMarkOfThisFetch) {
+                    record.fetchingVersion = undefined;
+                }
+            });
+        }
+    }
+    writeExplicitResult(key, name, result, viewUuid, sequence) {
+        if (!this.checkAndRecordWrite(key, sequence)) {
+            return;
+        }
+        const held = this.explicitEntries.get(key);
+        if (result.valueSetData) {
+            this.writeExplicitEntry(key, name, {
+                version: result.version,
+                data: result.valueSetData,
+                viewUuid,
+            });
+        }
+        else if (held && (held.version !== result.version || held.viewUuid !== viewUuid)) {
+            this.writeExplicitEntry(key, name, { ...held, version: result.version, viewUuid });
+        }
+    }
+    /** Values are the new version, a version alone is the one held, no version is a set gone. */
+    writeImplicitResult(viewUuid, key, result, sequence) {
+        // The entries of a view closed meanwhile are gone and stay so.
+        const held = this.viewEntries.get(viewUuid)?.get(key);
+        if (!held || !this.checkAndRecordWrite(createImplicitKey(viewUuid, key), sequence)) {
+            return;
+        }
+        if (result.valueSetData || !result.version) {
+            this.writeViewEntry(viewUuid, key, {
+                ...held,
+                implicit: true,
+                version: result.version,
+                data: result.valueSetData,
+            });
+        }
+    }
+    /**
+     * Whether nothing reads the explicit set and a view of the module holds it as its implicit set
+     * of the name, read by a selection in the set's namespace.
+     */
+    isHeldOnlyImplicitly(module, key, name, readKeys) {
+        return (!readKeys.has(key) &&
+            this.findViewsHoldingImplicitly(module, name).some((viewUuid) => {
+                const selection = this.viewSelections.get(viewUuid)?.get(name);
+                return (!!selection && createExplicitKey(module, selection.valueSetNamespace, name) === key);
+            }));
+    }
+    /** The views of the module holding an implicit set under the name. */
+    findViewsHoldingImplicitly(module, name) {
+        return [...this.viewEntries]
+            .filter(([viewUuid, entries]) => entries.get(name)?.implicit && this.findViewModule(viewUuid) === module)
+            .map(([viewUuid]) => viewUuid);
+    }
+    /**
+     * The keys of the explicit sets something reads: a selection of an open view whose view holds
+     * no implicit set of the name, the `label` pipe of an open view, or a subscriber of {@link get}.
+     */
+    collectReadExplicitKeys() {
+        const keys = new Set(this.subscriberCounts.keys());
+        this.readExplicitKeys.forEach((viewKeys) => viewKeys.forEach((key) => keys.add(key)));
+        this.viewSelections.forEach((selections, viewUuid) => {
+            const module = this.findViewModule(viewUuid);
+            selections.forEach((selection, name) => {
+                if (!this.viewEntries.get(viewUuid)?.get(name)?.implicit) {
+                    keys.add(createExplicitKey(module, selection.valueSetNamespace, name));
+                }
+            });
+        });
+        return keys;
+    }
+    releaseSubscriber(key) {
+        const count = this.subscriberCounts.get(key) - 1;
+        if (count) {
+            this.subscriberCounts.set(key, count);
+        }
+        else {
+            this.subscriberCounts.delete(key);
+        }
+    }
+    registerSelection(viewUuid, selection) {
+        if (this.closedViewUuids.has(viewUuid)) {
+            return;
+        }
+        const selections = this.viewSelections.get(viewUuid) ?? new Map();
+        selections.set(selection.valueSetName, selection);
+        this.viewSelections.set(viewUuid, selections);
+    }
+    registerExplicitRead(viewUuid, key) {
+        if (this.closedViewUuids.has(viewUuid)) {
+            return;
+        }
+        const keys = this.readExplicitKeys.get(viewUuid) ?? new Set();
+        keys.add(key);
+        this.readExplicitKeys.set(viewUuid, keys);
+    }
+    /** The namespace of the explicit set of the name in the module written last. */
+    findLastWrittenNamespace(module, name) {
+        let namespace;
+        this.explicitEntries.forEach((_, key) => {
+            const parsed = parseExplicitKey(key);
+            if (parsed.module === module && parsed.name === name) {
+                namespace = parsed.namespace;
+            }
+        });
+        return namespace;
+    }
+    isFetching(entryKey, version) {
+        return this.fetchRecords.get(entryKey)?.fetchingVersion === version;
+    }
+    markFetching(entryKey, version) {
+        const record = this.fetchRecords.get(entryKey) ?? { writtenSequence: 0 };
+        record.fetchingVersion = version;
+        this.fetchRecords.set(entryKey, record);
+    }
+    /**
+     * Records the fetch as the last writer of the entry, unless a later fetch wrote it already.
+     *
+     * @returns whether the answer of the fetch may write the entry.
+     */
+    checkAndRecordWrite(entryKey, sequence) {
+        const record = this.fetchRecords.get(entryKey) ?? { writtenSequence: 0 };
+        if (record.writtenSequence > sequence) {
+            return false;
+        }
+        record.writtenSequence = sequence;
+        this.fetchRecords.set(entryKey, record);
+        return true;
+    }
+    /** Drops the least recently written sets nothing reads beyond the count limit. */
+    evictExplicitEntries() {
+        const readKeys = this.collectReadExplicitKeys();
+        let count = this.explicitEntries.size;
+        for (const key of [...this.explicitEntries.keys()]) {
+            if (count <= this.sizeLimit) {
+                return;
+            }
+            if (!readKeys.has(key)) {
+                this.explicitEntries.delete(key);
+                this.fetchRecords.delete(key);
+                count--;
+            }
+        }
+    }
+    /** The values a widget of the view lists for its selection, see {@link getForSelection}. */
+    findForSelection(viewUuid, selection) {
+        const viewEntry = this.viewEntries.get(viewUuid)?.get(selection.valueSetName);
+        // An implicit set of the view wins: the explicit one is not read.
+        const data = viewEntry?.implicit
+            ? viewEntry.data
+            : this.explicitEntries.get(createExplicitKey(this.findViewModule(viewUuid), selection.valueSetNamespace, selection.valueSetName))?.data;
+        return data && this.mergeViewExtras(data, viewEntry, selection);
+    }
+    mergeViewExtras(data, viewEntry, selection) {
+        return viewEntry?.extraValues?.length || viewEntry?.excludedKeys?.length
+            ? mergeExtraValues(data, viewEntry, selection)
+            : data;
+    }
+    /** Emits the values the read gives now and again whenever the store writes a set of the name. */
+    followChanges(name, read) {
+        return this.changes.pipe(filter((changed) => changed === name), startWith(name), map(read), distinctUntilChanged(deepEqual));
+    }
+    /** The module a view is served by; the empty string stands for the session's own backend. */
+    findViewModule(viewUuid) {
+        return (this.injector
+            .get(SmartViewContextService)
+            .getCurrentViewContext()
+            ?.views?.find((view) => view.uuid === viewUuid)?.module ?? "");
+    }
+    /** Writes the explicit entry as the most recently written one. */
+    writeExplicitEntry(key, name, entry) {
+        this.explicitEntries.delete(key);
+        this.explicitEntries.set(key, entry);
+        this.changeSource.next(name);
+    }
+    writeViewEntry(viewUuid, key, entry) {
+        const entries = this.viewEntries.get(viewUuid) ?? new Map();
+        entries.set(key, entry);
+        this.viewEntries.set(viewUuid, entries);
+        this.changeSource.next(key);
+    }
+}
+/**
+ * The set without the values whose text at the set's key property is an excluded key, then the
+ * view's extras keyed by their code under the selection's key property, unless the set has the key.
+ */
+function mergeExtraValues(data, extras, selection) {
+    const values = data.values ?? [];
+    const keyProperty = valueSetKeyProperty(values, selection.keyProperty ?? data.keyProperty);
+    const displayProperty = valueSetDisplayProperty(values, selection.displayProperty);
+    const excludedKeys = new Set(extras.excludedKeys ?? []);
+    const keptValues = values.filter((value) => {
+        const key = data.keyProperty ? value?.[data.keyProperty] : undefined;
+        return key === undefined || key === null || !excludedKeys.has(String(key));
+    });
+    const keys = new Set(keptValues.map((value) => convertKeyToText(value?.[keyProperty])));
+    const extraValues = (extras.extraValues ?? [])
+        .filter((extra) => extra.code !== undefined && !keys.has(extra.code))
+        .map((extra) => ({
+        ...extra,
+        [keyProperty]: extra.code,
+        [displayProperty]: extra.displayValue,
+    }));
+    return { ...data, values: [...keptValues, ...extraValues] };
+}
+function convertKeyToText(key) {
+    return key === undefined || key === null ? undefined : String(key);
+}
+function createExplicitKey(module, namespace, name, branchUri) {
+    return JSON.stringify([module ?? "", namespace ?? "", name, branchUri ?? ""]);
+}
+/** The parts of an explicit key, an empty namespace or branch as undefined. */
+function parseExplicitKey(key) {
+    const [module, namespace, name, branchUri] = JSON.parse(key);
+    return {
+        module,
+        namespace: namespace || undefined,
+        name,
+        branchUri: branchUri || undefined,
+    };
+}
+function createImplicitKey(viewUuid, key) {
+    return JSON.stringify([viewUuid, key]);
+}
+
 class SmartNavigationService {
     constructor() { }
     subscribeToUrlChange(callback) {
@@ -7086,31 +7763,6 @@ var ValueChangeMode;
     ValueChangeMode["BLUR"] = "BLUR";
 })(ValueChangeMode || (ValueChangeMode = {}));
 
-/**
- * The key and display property of a valueSet's values: the preferred name if the values carry it,
- * then the GenericValue name (`uri` / `name`), then the Value name (`objectUri` / `displayValue`).
- * With no sample value to look at the preferred name is assumed to exist.
- */
-function valueSetKeyProperty(values, preferred) {
-    return firstExisting(values, [preferred ?? 'objectUri', 'uri', 'objectUri']);
-}
-function valueSetDisplayProperty(values, preferred) {
-    return firstExisting(values, [preferred ?? 'displayValue', 'name', 'displayValue']);
-}
-/** The label of a code in a valueSet, or undefined when the valueSet does not know the code. */
-function valueSetLabelOf(valueSet, code) {
-    const values = valueSet.valueSetData?.values ?? [];
-    const keyProperty = valueSetKeyProperty(values, valueSet.valueSetData?.keyProperty);
-    const hit = values.find((value) => String(value[keyProperty]) === String(code));
-    return hit?.[valueSetDisplayProperty(values)];
-}
-function firstExisting(values, candidates) {
-    if (!values?.length) {
-        return candidates[0];
-    }
-    return candidates.find((c) => c in values[0]) ?? candidates[candidates.length - 1];
-}
-
 const EMPTY_PARAMS = {};
 const NAMED_VALIDATOR = new InjectionToken('Named validator factory');
 
@@ -7223,6 +7875,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImpor
 class SmartFormService {
     constructor() {
         this.validatorProvider = inject(NamedValidatorService, { optional: true });
+        /** Looks up the value set store at use: a form without a view does not need it. */
+        this.injector = inject(Injector);
         this.revisionState = signal(0, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "revisionState" }] : /* istanbul ignore next */ []));
         /**
@@ -7247,6 +7901,8 @@ class SmartFormService {
          * says nothing about what the data holds.
          */
         this.exchanged = new Map();
+        /** The values each selection widget's `valueList` was last filled from. */
+        this.filledValueSets = new WeakMap();
         this.regexRegexChars = new RegExp(/[\.\-\[\]\/\{\}\(\)\+\^\$\\\|]/g);
         this.regexAsteriskInTheMiddle = new RegExp(/([^\*])\*([^\*])/g);
         this.regexAsteriskInTheEnd = new RegExp(/([^\*])\*$/g);
@@ -7405,7 +8061,7 @@ class SmartFormService {
                         // The backend changed this field: its value reaches the control even over an edit.
                         this.group[key]?.setValue(value ?? '', { emitEvent: false });
                     }
-                    this.copyFromValueSetToValuesList(widget, smartForm.componentModel.valueSets);
+                    this.fillValueListFromValueSet(widget);
                 }
                 else {
                     // In case of CheckBox2
@@ -7413,62 +8069,113 @@ class SmartFormService {
                     splittedKeys.splice(splittedKeys.length - 1, 1);
                     widget = this.findSmartFormWidgetByKey(widgets, splittedKeys.join('.'));
                     if (widget && widget.type === SmartFormWidgetType.CHECK_BOX_2) {
-                        this.copyFromValueSetToValuesList(widget, smartForm.componentModel.valueSets);
-                        if (widget.valueList) {
-                            widget.valueList = widget.valueList.map((item) => {
-                                let value = this.getValueDeeply(data, `${widget?.key}.${item.key}`);
-                                item.value = value;
-                                return item;
-                            });
-                        }
+                        this.fillValueListFromValueSet(widget);
+                        this.fillCheckBoxItemValues(widget, data);
                     }
                 }
             }
         }
     }
-    copyFromValueSetToValuesList(widget, valueSets) {
-        if (widget.type === SmartFormWidgetType.SELECT ||
-            widget.type === SmartFormWidgetType.SELECT_MULTIPLE ||
-            widget.type === SmartFormWidgetType.RADIO_BUTTON ||
-            widget.type === SmartFormWidgetType.CHECK_BOX_2 ||
-            widget.type === SmartFormWidgetType.TEXT_FIELD) {
-            if (widget.selection && valueSets) {
-                let valueSet = valueSets[widget.selection.valueSetName];
-                if (!valueSet) {
-                    console.warn('valueSet not found', widget.selection.valueSetName);
-                }
-                else {
-                    let valueSetData = valueSet.valueSetData;
-                    let values = valueSetData.values;
-                    let selectionDefinition = widget.selection;
-                    let displayProperty = valueSetDisplayProperty(values, selectionDefinition?.displayProperty);
-                    if (widget.selection.type === SelectionDefinitionTypeEnum.PROPERTY &&
-                        !widget.selection.mapping.length) {
-                        let keyProperty = valueSetKeyProperty(values, selectionDefinition?.keyProperty ?? valueSetData?.keyProperty);
-                        widget.valueList = values.map((value) => {
-                            return {
-                                key: value[keyProperty],
-                                label: value[displayProperty],
-                                type: SmartFormWidgetType.ITEM,
-                                value: value[keyProperty],
-                            };
-                        });
-                        this.addEmptyItemToValueList(widget, widget.selection.emptyLabel);
-                    }
-                    else if (widget.selection.type === SelectionDefinitionTypeEnum.OBJECT &&
-                        !widget.selection.mapping.length) {
-                        widget.valueList = values.map((value, index) => {
-                            return {
-                                key: `${index}`,
-                                label: value[displayProperty],
-                                type: SmartFormWidgetType.ITEM,
-                                value: value,
-                            };
-                        });
-                        this.addEmptyItemToValueList(widget);
-                    }
+    /**
+     * Lists the values of a selection widget's value set each time the model writes the field, the
+     * empty item of a SELECT included, also where a mandatory constraint removed it: the set of the
+     * form's own component model, else the values the store last gave the widget.
+     */
+    fillValueListFromValueSet(widget) {
+        const valueSetData = this.findOwnValueSetData(widget) ?? this.filledValueSets.get(widget);
+        if (valueSetData) {
+            this.fillValueList(widget, valueSetData);
+        }
+    }
+    /**
+     * The set a selection widget's form carries in its own component model under the selection's
+     * name: a form a host builds, or a delivery without the store. It wins over the store's.
+     */
+    findOwnValueSetData(widget) {
+        if (!isListedFromValueSet(widget)) {
+            return undefined;
+        }
+        const name = widget.selection.valueSetName;
+        return this.smartForm?.componentModel?.valueSets?.[name]?.valueSetData;
+    }
+    /**
+     * The store's values for the selection widget in its view, emitted at once and at every new
+     * version; nothing for a widget that lists no value set.
+     */
+    observeValueSetData(widget, viewUuid) {
+        if (!isListedFromValueSet(widget)) {
+            return undefined;
+        }
+        return this.injector
+            .get(SmartValueSetStore)
+            .getForSelection(viewUuid, widget.selection);
+    }
+    /**
+     * Lists the values the store gave the widget when they are not the ones listed, unless its form
+     * carries its own; a checkbox group gets the values of its items from the data and a control for
+     * each new item.
+     *
+     * @returns whether the widget lists new values.
+     */
+    relistValueSet(widget, storeValueSetData, form) {
+        const valueSetData = this.findOwnValueSetData(widget) ?? storeValueSetData;
+        if (!valueSetData || deepEqual(this.filledValueSets.get(widget), valueSetData)) {
+            return false;
+        }
+        this.fillValueList(widget, valueSetData);
+        if (widget.type === SmartFormWidgetType.CHECK_BOX_2) {
+            this.fillCheckBoxItemValues(widget, this.smartForm?.componentModel?.data);
+            // The widget's form, not this service's controls: a host may give the widget its own form.
+            widget.valueList.forEach((item) => {
+                const key = `${widget.key}.${item.key}`;
+                if (form && !form.controls[key]) {
+                    form.addControl(key, new UntypedFormControl({ value: item.value ?? '', disabled: !!widget.isDisabled }), { emitEvent: false });
                 }
-            }
+            });
+        }
+        return true;
+    }
+    /** Gives each item of a checkbox group its value from the data. */
+    fillCheckBoxItemValues(widget, data) {
+        widget.valueList = widget.valueList?.map((item) => {
+            item.value = data ? this.getValueDeeply(data, `${widget.key}.${item.key}`) : undefined;
+            return item;
+        });
+    }
+    /**
+     * Fills the `valueList` of a selection widget from the values of its value set, a SELECT with
+     * the empty item; a constraint that makes the widget mandatory removes it.
+     */
+    fillValueList(widget, valueSetData) {
+        this.filledValueSets.set(widget, valueSetData);
+        let values = valueSetData.values;
+        let select = widget;
+        let selection = select.selection;
+        let displayProperty = valueSetDisplayProperty(values, selection.displayProperty);
+        if (selection.type === SelectionDefinitionTypeEnum.PROPERTY &&
+            !selection.mapping?.length) {
+            let keyProperty = valueSetKeyProperty(values, selection.keyProperty ?? valueSetData?.keyProperty);
+            select.valueList = values.map((value) => {
+                return {
+                    key: value[keyProperty],
+                    label: value[displayProperty],
+                    type: SmartFormWidgetType.ITEM,
+                    value: value[keyProperty],
+                };
+            });
+            this.addEmptyItemToValueList(select, selection.emptyLabel);
+        }
+        else if (selection.type === SelectionDefinitionTypeEnum.OBJECT &&
+            !selection.mapping?.length) {
+            select.valueList = values.map((value, index) => {
+                return {
+                    key: `${index}`,
+                    label: value[displayProperty],
+                    type: SmartFormWidgetType.ITEM,
+                    value: value,
+                };
+            });
+            this.addEmptyItemToValueList(select);
         }
     }
     toFormGroup() {
@@ -7806,6 +8513,15 @@ class SmartFormService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SmartFormService, decorators: [{
             type: Injectable
         }] });
+/** Whether the widget lists the values of the value set its selection names. */
+function isListedFromValueSet(widget) {
+    return ((widget.type === SmartFormWidgetType.SELECT ||
+        widget.type === SmartFormWidgetType.SELECT_MULTIPLE ||
+        widget.type === SmartFormWidgetType.RADIO_BUTTON ||
+        widget.type === SmartFormWidgetType.CHECK_BOX_2 ||
+        widget.type === SmartFormWidgetType.TEXT_FIELD) &&
+        !!widget.selection);
+}
 /**
  * Splits a date-time widget's backend value into the `HH:mm` text of its companion
  * `<key>-time` control, and normalizes the widget's own value to a `Date` for the picker.
@@ -8866,11 +9582,11 @@ const PIPES = {
     time: (v, arg, ctx) => formatDate(v, arg ?? 'H:mm', ctx),
     number: (v, arg, ctx) => formatNumber(v, arg ?? '1.0-3', ctx),
     label: (v, arg, ctx) => {
-        const valueSet = ctx.valueSets?.[arg];
-        if (isEmpty(v) || !valueSet) {
+        const valueSetData = isEmpty(v) ? undefined : ctx.findValueSetData?.(arg);
+        if (!valueSetData) {
             return v;
         }
-        return valueSetLabelOf(valueSet, v) ?? v;
+        return valueSetLabelOf(valueSetData, v) ?? v;
     },
     default: (v, arg) => (isEmpty(v) ? (arg ?? '') : v),
     upper: (v, _arg, ctx) => (isEmpty(v) ? v : String(v).toLocaleUpperCase(locales(ctx))),
@@ -9387,6 +10103,32 @@ function ownAttribute(element, name, value, wanted, owned) {
     return owned;
 }
 
+/**
+ * The lookup the `label` pipe reads a value set through by its name: the set a component model
+ * carries under the name (a form a host builds, or a delivery without the store), else the set
+ * the value set store serves the view under the name.
+ */
+function createValueSetLookup(valueSets, store, viewUuid) {
+    return (name) => valueSets?.[name]?.valueSetData ?? (viewUuid ? store.findByName(viewUuid, name) : undefined);
+}
+function injectValueSetReads() {
+    const changed = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "changed" }] : /* istanbul ignore next */ []));
+    let names = new Set();
+    inject(SmartValueSetStore)
+        .changes.pipe(filter((name) => names.has(name)), takeUntilDestroyed())
+        .subscribe(() => changed.update((count) => count + 1));
+    return {
+        changed: changed.asReadonly(),
+        track: (lookup) => {
+            names = new Set();
+            return (name) => {
+                names.add(name);
+                return lookup(name);
+            };
+        },
+    };
+}
 /**
  * The class the container carries while the html on screen is about to be replaced. A style sheet
  * that gives it an animation or transition plays that before the new html is written; without one
@@ -9498,7 +10240,7 @@ function injectSmartHtmlRenderer(container) {
         render: (newTemplate, context) => untracked(() => {
             template = newTemplate;
             const result = resolveTemplate(template, context.data, {
-                valueSets: context.valueSets,
+                findValueSetData: context.findValueSetData,
                 locale: locale(),
                 warn,
             });
@@ -9548,24 +10290,28 @@ function injectSmartHtmlRenderer(container) {
 /**
  * The HTML widget: server-sent HTML whose client placeholders are resolved against the model of
  * the form it sits on, the widget's `root` applied. It has no control, no label and no value of
- * its own; it follows the form's revision and re-resolves, which rewrites the html only when the
- * result differs. See HTML-WIDGET.md.
+ * its own; it follows the form's revision and the value sets it reads and re-resolves, which
+ * rewrites the html only when the result differs. See HTML-WIDGET.md.
  */
 class SmartHtmlWidgetComponent {
     constructor() {
         this.service = inject(SmartFormService);
+        this.valueSetStore = inject(SmartValueSetStore);
+        this.valueSetReads = injectValueSetReads();
+        this.smartComponent = injectSmartComponent();
         this.renderer = injectSmartHtmlRenderer(inject(ElementRef).nativeElement);
         this.widgetInstance = input.required(/* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "widgetInstance" }] : /* istanbul ignore next */ []));
         effect(() => {
             this.service.revision();
+            this.valueSetReads.changed();
             const properties = this.widgetInstance().htmlProperties;
             const model = this.service.smartForm?.componentModel;
             this.warnUnloaded(properties);
             this.renderer.useCss(properties?.css);
             this.renderer.render(properties?.html ?? '', {
                 data: this.scope(model?.data, properties?.root, properties?.html),
-                valueSets: model?.valueSets,
+                findValueSetData: this.valueSetReads.track(createValueSetLookup(model?.valueSets, this.valueSetStore, this.smartComponent?.uuid)),
                 icons: properties?.icons,
             });
         });
@@ -10175,6 +10921,7 @@ class SmartformwidgetComponent {
             }
             this.filteredOptions = this.onValueChange.pipe(startWith(""), map((value) => this._filter(value || "")), takeUntil(this._destroy$));
         }
+        this.followValueSet();
         if (this.widgetInstance.type === SmartFormWidgetType.YOUTUBE_PLAYER) {
             let videoId = this.parseYoutubeUrl(this.widgetInstance.link);
             if (videoId)
@@ -10201,6 +10948,24 @@ class SmartformwidgetComponent {
             });
         });
     }
+    /**
+     * Lists the value set of a selection widget from the value set store and lists it again at
+     * every new version, with no change of the data. A form without a view follows its own model.
+     */
+    followValueSet() {
+        const viewUuid = this.smartComponent?.uuid;
+        if (!viewUuid) {
+            return;
+        }
+        this.service
+            .observeValueSetData(this.widgetInstance, viewUuid)
+            ?.pipe(takeUntil(this._destroy$))
+            .subscribe((valueSetData) => {
+            if (this.service.relistValueSet(this.widgetInstance, valueSetData, this.form())) {
+                this.changeDetector.markForCheck();
+            }
+        });
+    }
     getSophisticatedEventKind() {
         return this.widgetInstance.type === SmartFormWidgetType.SELECT ||
             this.widgetInstance.type === SmartFormWidgetType.SELECT_MULTIPLE ||
@@ -11946,6 +12711,7 @@ class SmartViewContextService {
         this.dialog = inject(SmartViewContextDialogService);
         this.apiQueueService = inject(ApiQueueService);
         this.themeService = inject(ThemeService);
+        this.valueSetStore = inject(SmartValueSetStore);
         this.inject = inject(Injector);
         this.smartConfig = inject(SMART_NG_CLIENT_CONFIG);
         this.viewContextUuidName = "viewContextUuid";
@@ -12936,7 +13702,10 @@ class SmartViewContextService {
         await this.sendViewContextUpdates(updates);
         this.viewContextHasBeenSynced.next();
     }
-    /** Opens and closes the views as the view context says, returns the states to report. */
+    /**
+     * Opens and closes the views as the view context says, returns the states to report. A closed
+     * view's implicit value sets are dropped from the value set store.
+     */
     syncViewStates() {
         const updates = [];
         const ops = buildViewOps(this.viewContext?.views ?? [], this.reuseEnabled());
@@ -12968,6 +13737,9 @@ class SmartViewContextService {
                 updates.push(...this.closeView(viewData));
             });
         }
+        updates
+            .filter((update) => update?.state === ViewState.CLOSED && update.uuid)
+            .forEach((update) => this.valueSetStore.removeView(update.uuid));
         return updates;
     }
     async startDownloadsFiles(downloads) {
@@ -13050,7 +13822,7 @@ class SmartViewContextService {
     async message(messageData, messageResult) {
         return await this.handlePerformActionResponse(await this.view
             .message(messageData.viewUuid ?? "", messageData.uuid, messageResult)
-            .toPromise());
+            .toPromise(), messageData.viewUuid);
         // in future use this.apiQueueService.addToQueue
     }
     getSmartViewContextApiErrorByCode(code) {
@@ -13183,27 +13955,27 @@ class SmartViewContextService {
     async _performAction(config) {
         return await this.handlePerformActionResponse(await this.withModelSync(config.uiActionRequest, () => this.view
             .performAction(config.uuid, config.uiActionRequest)
-            .toPromise()));
+            .toPromise()), config.uuid);
     }
     async _performWidgetAction(config) {
         return await this.handlePerformActionResponse(await this.withModelSync(config.uiActionRequest, () => this.view
             .performWidgetAction(config.uuid, config.widgetId, config.nodeId, config.uiActionRequest)
-            .toPromise()));
+            .toPromise()), config.uuid);
     }
     async _performWidgetMainAction(config) {
         return await this.handlePerformActionResponse(await this.withModelSync(config.uiActionRequest, () => this.view
             .performWidgetMainAction(config.uuid, config.widgetId, config.uiActionRequest)
-            .toPromise()));
+            .toPromise()), config.uuid);
     }
     async _performUploadAction(config) {
         return await this.handlePerformActionResponse(await this.withModelSync(config.uiActionRequest, () => this.view
             .uploadAction(config.uuid, JSON.stringify(config.uiActionRequest), config.param, config.content)
-            .toPromise()));
+            .toPromise()), config.uuid);
     }
     async _performUploadMultipleAction(config) {
         return await this.handlePerformActionResponse(await this.withModelSync(config.uiActionRequest, () => this.view
             .uploadMultipleAction(config.uuid, JSON.stringify(config.uiActionRequest), config.param, config.content)
-            .toPromise()));
+            .toPromise()), config.uuid);
     }
     /**
      * Calls run concurrently, so the response of an earlier call can land after that of a later
@@ -13220,8 +13992,22 @@ class SmartViewContextService {
      * reports it closed; the applied view context lists such a view OPENED only because an OPENED
      * report of the client reached the server after the close. So a view to be closed in the view
      * context not applied is closed all the same.
+     *
+     * The Value Set Version Map of the change goes to the value set store, whose fetches are held
+     * until the change is applied, so one request carries the implicit sets the changed models name.
+     * The fetch is not awaited: the widgets follow the store.
      */
-    async handlePerformActionResponse(viewContextChange) {
+    async handlePerformActionResponse(viewContextChange, viewUuid) {
+        // The implicit sets the changed models name go in the Value Set Fetch of the version map.
+        const releaseValueSetFetches = this.valueSetStore.holdFetches();
+        try {
+            return await this.applyPerformActionResponse(viewContextChange, viewUuid);
+        }
+        finally {
+            releaseValueSetFetches();
+        }
+    }
+    async applyPerformActionResponse(viewContextChange, viewUuid) {
         await Promise.allSettled(this.runningViewContextUpdates);
         const sequence = viewContextChange?.viewContext?.sequence;
         const applied = this.viewContext?.sequence;
@@ -13239,6 +14025,9 @@ class SmartViewContextService {
         if (viewContextChange?.changes) {
             this.handleChanges(viewContextChange.changes);
         }
+        this.valueSetStore
+            .applyVersions(viewContextChange, viewUuid)
+            .catch((err) => console.error("value set fetch failed", err));
         return viewContextChange?.result;
     }
     handleChanges(changes) {
@@ -13256,7 +14045,7 @@ class SmartViewContextService {
         let change = await this.view.getComponentModel2(uuid).toPromise();
         // Not awaited: the sync ends with a viewcontext PUT, which would serialise the mount.
         // The failure still has to surface, so log it instead of dropping the promise.
-        this.handlePerformActionResponse(change).catch((err) => console.error("syncView after component load failed", err));
+        this.handlePerformActionResponse(change, uuid).catch((err) => console.error("syncView after component load failed", err));
         return change;
     }
     getCurrentViewContext() {
@@ -15064,7 +15853,8 @@ function rowActionModels(row, gridIdentifier, serviceToUse) {
 /**
  * A table cell rendered from a column template: server-sent HTML whose client placeholders are
  * resolved against the row's data, the template's `root` applied. The toolbar slots and action
- * triggers in it offer the row's actions, the way a card's row layout does.
+ * triggers in it offer the row's actions, the way a card's row layout does. A new version of a
+ * value set it reads renders it again, which rewrites the html only when the result differs.
  *
  * The cell provides the action host itself rather than the row: the table creates its cells
  * from templates declared in the table, so they inject from there, never from the row element.
@@ -15074,10 +15864,23 @@ class SmartHtmlCellComponent {
     constructor() {
         this.actionHost = inject(SmartActionHost);
         this.smartComponent = injectSmartComponent();
+        this.valueSetStore = inject(SmartValueSetStore);
+        this.valueSetReads = injectValueSetReads();
         this.renderer = injectSmartHtmlRenderer(inject(ElementRef).nativeElement);
+        effect(() => {
+            this.valueSetReads.changed();
+            untracked(() => {
+                if (this.row && this.template) {
+                    this.renderTemplate();
+                }
+            });
+        });
     }
     ngOnChanges() {
         this.actionHost.actionModels.set(rowActionModels(this.row, this.gridIdentifier));
+        this.renderTemplate();
+    }
+    renderTemplate() {
         const { html, root, css, icons } = this.template;
         const scope = rootScope(this.row.data, root);
         if (scope === undefined && root && this.warnedRoot !== root) {
@@ -15088,7 +15891,7 @@ class SmartHtmlCellComponent {
         this.renderer.useCss(css);
         this.renderer.render(html ?? '', {
             data: scope,
-            valueSets: this.smartComponent?.model?.valueSets,
+            findValueSetData: this.valueSetReads.track(createValueSetLookup(this.smartComponent?.model?.valueSets, this.valueSetStore, this.smartComponent?.uuid)),
             icons,
         });
     }
@@ -15098,7 +15901,7 @@ class SmartHtmlCellComponent {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: SmartHtmlCellComponent, decorators: [{
             type: Component,
             args: [{ selector: 'smart-html-cell', template: '', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [SmartActionHost], styles: ["smart-html-cell{display:block}smart-html-cell [data-sb4-action]{cursor:pointer}smart-html-cell [data-sb4-action].sb4-action-inert{cursor:inherit}smart-html-cell [data-sb4-action].sb4-action-disabled{cursor:default;opacity:.5}\n"] }]
-        }], propDecorators: { row: [{
+        }], ctorParameters: () => [], propDecorators: { row: [{
                 type: Input,
                 args: [{ required: true }]
             }], template: [{
@@ -18266,8 +19069,8 @@ class SmarttreeGenericService extends SmarttreeService {
     }
     async downloadTree() {
         let uuid = this.viewContext.getUuidOfPage(this.pageName);
-        const rootNodes = await this.viewContext.handlePerformActionResponse(await this.service.getRootNodes2(uuid, this.treeId).toPromise());
-        const uiActions = await this.viewContext.handlePerformActionResponse(await this.service.getMainActions2(uuid, this.treeId).toPromise());
+        const rootNodes = await this.viewContext.handlePerformActionResponse(await this.service.getRootNodes2(uuid, this.treeId).toPromise(), uuid);
+        const uiActions = await this.viewContext.handlePerformActionResponse(await this.service.getMainActions2(uuid, this.treeId).toPromise(), uuid);
         if (uiActions) {
             this.constructUiActionModels(uiActions);
         }
@@ -18282,7 +19085,7 @@ class SmarttreeGenericService extends SmarttreeService {
     }
     async downloadChildren(parentNode) {
         let uuid = this.viewContext.getUuidOfPage(this.pageName);
-        const children = await this.viewContext.handlePerformActionResponse(await this.service.getChildrenNodes2(uuid, this.treeId, parentNode.identifier).toPromise());
+        const children = await this.viewContext.handlePerformActionResponse(await this.service.getChildrenNodes2(uuid, this.treeId, parentNode.identifier).toPromise(), uuid);
         if (!children) {
             throw new Error(`Node with identifier ${parentNode.identifier} does not have children.`);
         }
@@ -18291,11 +19094,11 @@ class SmarttreeGenericService extends SmarttreeService {
     async onTreeNodeOpen(treeNode) {
         let viewUuid = this.viewContext.getUuidOfPage(this.pageName);
         if (treeNode?.expanded) {
-            let tempTreeNode = await this.viewContext.handlePerformActionResponse(await this.service.collapseNode2(viewUuid, this.treeId, treeNode.identifier).toPromise());
+            let tempTreeNode = await this.viewContext.handlePerformActionResponse(await this.service.collapseNode2(viewUuid, this.treeId, treeNode.identifier).toPromise(), viewUuid);
             treeNode = tempTreeNode;
         }
         else if (!treeNode?.expanded) {
-            let tempTreeNode = await this.viewContext.handlePerformActionResponse(await this.service.expandNode2(viewUuid, this.treeId, treeNode?.identifier).toPromise());
+            let tempTreeNode = await this.viewContext.handlePerformActionResponse(await this.service.expandNode2(viewUuid, this.treeId, treeNode?.identifier).toPromise(), viewUuid);
             treeNode = tempTreeNode;
         }
         let node = this.deepSearchTreeNode(treeNode?.identifier, this.treeFromBackend);
@@ -18308,7 +19111,7 @@ class SmarttreeGenericService extends SmarttreeService {
     }
     async selectFolder(folderUri, treeNode) {
         let viewUuid = this.viewContext.getUuidOfPage(this.pageName);
-        let updatedTreeNode = await this.viewContext.handlePerformActionResponse(await this.viewContext.withModelSync({}, (request) => this.service.selectNode2(viewUuid, this.treeId, treeNode.identifier, request).toPromise()));
+        let updatedTreeNode = await this.viewContext.handlePerformActionResponse(await this.viewContext.withModelSync({}, (request) => this.service.selectNode2(viewUuid, this.treeId, treeNode.identifier, request).toPromise()), viewUuid);
         if (this.selectedNode) {
             this.selectedNode.selected = false;
         }
@@ -18522,11 +19325,11 @@ class SmarttreeGenericService extends SmarttreeService {
         let nodeId = uiActionRequest.params['nodeUuid'];
         delete uiActionRequest.params['nodeUuid'];
         let viewUuid = this.viewContext.getUuidOfPage(this.pageName);
-        this.treeFromBackend = await this.viewContext.handlePerformActionResponse(await this.viewContext.withModelSync(uiActionRequest, (request) => this.service.performAction2(viewUuid, this.treeId, nodeId, request).toPromise()));
+        this.treeFromBackend = await this.viewContext.handlePerformActionResponse(await this.viewContext.withModelSync(uiActionRequest, (request) => this.service.performAction2(viewUuid, this.treeId, nodeId, request).toPromise()), viewUuid);
     }
     async performMainUiActionRequest(uiActionRequest) {
         let viewUuid = this.viewContext.getUuidOfPage(this.pageName);
-        this.treeFromBackend = await this.viewContext.handlePerformActionResponse(await this.viewContext.withModelSync(uiActionRequest, (request) => this.service.performMainAction2(viewUuid, this.treeId, request).toPromise()));
+        this.treeFromBackend = await this.viewContext.handlePerformActionResponse(await this.viewContext.withModelSync(uiActionRequest, (request) => this.service.performMainAction2(viewUuid, this.treeId, request).toPromise()), viewUuid);
     }
     handleSpecificDemandsAsynchronously(uiAction, uiActionRequest) {
         throw new Error('Method not implemented.');
@@ -18714,6 +19517,9 @@ class SmartComponentApiClient {
     set model(model) {
         this.modelState.set(model);
         this.actionsState.set(model?.actions);
+        if (this.uuid) {
+            this.valueSetStore.putImplicit(this.uuid, model?.valueSets);
+        }
         this.initComponentByModel();
     }
     get data() {
@@ -18814,6 +19620,7 @@ class SmartComponentApiClient {
         }
         this.viewContext = inject.get(SmartViewContextService);
         this.bootstrap = inject.get(SmartBackendBootstrapService);
+        this.valueSetStore = inject.get(SmartValueSetStore);
         if (this._componentName) {
             let pageNameForComponent = this.viewContext.getPageNameOfComponent(this._componentName);
             if (!this.pageName) {
@@ -19295,6 +20102,7 @@ class SmartComponentApiClient {
     handleValueSetChange(changes, changeKey) {
         let valueSetKey = changeKey.split('.')[1];
         this.model.valueSets[valueSetKey] = changes[changeKey];
+        this.valueSetStore.putImplicit(this.uuid, { [valueSetKey]: changes[changeKey] });
     }
     handleActionChange(changes, changeKey) {
         this.model.actions = changes[changeKey];
@@ -21694,13 +22502,13 @@ class SmartGridComponent {
         this.isBlocked = true;
         const row = this.service.gridModel.page.rows?.find((gridRow) => gridRow.id === rowId);
         const viewContextChange = await this.service.select(this.smartGrid, row);
-        this.smartGrid.viewContextService.handlePerformActionResponse(viewContextChange);
+        this.smartGrid.viewContextService.handlePerformActionResponse(viewContextChange, this.smartGrid.gridModel.viewUuid);
         this.refresh();
     }
     async onSelectAll(selected) {
         this.isBlocked = true;
         const viewContextChange = await this.service.selectAll(this.smartGrid, selected);
-        this.smartGrid.viewContextService.handlePerformActionResponse(viewContextChange);
+        this.smartGrid.viewContextService.handlePerformActionResponse(viewContextChange, this.smartGrid.gridModel.viewUuid);
         this.refresh();
     }
     async onSelectRows(selectedIds, unselectedIds) {
@@ -21708,7 +22516,7 @@ class SmartGridComponent {
         let selected = selectedIds.filter((item) => item !== undefined);
         let unselected = unselectedIds.filter((item) => item !== undefined);
         const viewContextChange = await this.service.selectRows(this.smartGrid, selected, unselected);
-        this.smartGrid.viewContextService.handlePerformActionResponse(viewContextChange);
+        this.smartGrid.viewContextService.handlePerformActionResponse(viewContextChange, this.smartGrid.gridModel.viewUuid);
         this.refresh();
     }
     editColumns() {
@@ -23253,7 +24061,7 @@ class SmartMapComponent {
                         return null;
                     }
                     else {
-                        return this.viewContextService.handlePerformActionResponse(change);
+                        return this.viewContextService.handlePerformActionResponse(change, this.uuid);
                     }
                 }, (err) => {
                     console.warn('Could not submit selection change! ', err);
@@ -25806,10 +26614,8 @@ class SmartComponentLayoutComponent {
         this.smartForm = {
             direction: this.getFormLayout(),
             // A row gets an envelope rather than being written into: its `data` stays the row's own
-            // object, and the valueSets of the page come along by reference.
-            componentModel: gridRow
-                ? { ...gridRow, valueSets: gridRow.valueSets ?? this.smartComponent?.model?.valueSets }
-                : this.smartComponent?.model,
+            // object. Its widgets read the value sets of the page's view from the value set store.
+            componentModel: gridRow ? { ...gridRow } : this.smartComponent?.model,
             widgets,
         };
     }
@@ -26803,6 +27609,8 @@ var ACLEntry;
  * Do not edit the class manually.
  */
 
+/** The key of the view's value set that lists the operations of the matrix. */
+const OPERATIONS = 'OPERATIONS';
 class AclEditingViewComponent extends SmartComponent {
     get smartForm() {
         return this.smartFormState();
@@ -26824,13 +27632,16 @@ class AclEditingViewComponent extends SmartComponent {
          */
         this.aclActionModels = computed(() => this.actionModels().map((model) => model.uiAction.code === 'SAVE' ? { ...model, exception: true } : model), /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "aclActionModels" }] : /* istanbul ignore next */ []));
-        this.dataChanged.pipe(takeUntil$1(this._destroy$)).subscribe(() => {
-            this.constructForm();
+        // The operations come from the value set store, which may get them after the data.
+        this.dataChanged
+            .pipe(switchMap(() => this.valueSetStore.getImplicit(this.uuid, OPERATIONS)), filter$1((operations) => !!operations), takeUntil$1(this._destroy$))
+            .subscribe((operations) => {
+            this.constructForm(operations);
             this.initActions();
         });
     }
-    constructForm() {
-        let tempOpartions = this.model.valueSets['OPERATIONS'].valueSetData.values.map((value) => value.toString());
+    constructForm(operations) {
+        let tempOpartions = operations.values.map((value) => value.toString());
         let widgets = this.formService.render({
             layoutDefinitions: this.model.layouts['ACL_MATRIX'].widgets,
         });
@@ -27151,5 +27962,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ACLEntry, APIS$5 as APIS, AclEditingViewComponent, ApiModule$4 as ApiModule, ApiQueueService, BASE_PATH$7 as BASE_PATH, COLLECTION_FORMATS$7 as COLLECTION_FORMATS, CUSTOM_DIAGRAM_OPTIONS, CloseResult, ComponentFactoryService, ComponentType, ComponentWidgetType, Configuration$7 as Configuration, DEFAULT_ROW_LAYOUT, DIALOG_DISABLE_CLOSE, DataChangeKind, DefaultChartOptionsProvider, DefaultUiActionCode_CLOSE, DrawTime, EMPTY_PARAMS, ExpandableSectionButtonIconPosition, ExpandableSectionButtonType, ExpandableSectionComponent, FilterExpressionBoolOperator$1 as FilterExpressionBoolOperator, FilterExpressionBuilderGroupBuilderGroupKindEnum, FilterExpressionBuilderUiModelTypeEnum, FilterExpressionDataType, FilterExpressionFieldWidgetType, FilterExpressionOperation, FilterExpressionOrderByOrderEnum, GenericPageComponent, GeoMapDataLoadingMode, GeoMapDataSourceType, GeoMapItemKind, GeoMapOperationMode, GeoMapSelectionMode, GeoMapTextType, GridColumnContentType, GridDataAccessConfigKindEnum, GridDefaultRowActionTrigger, GridRowStateDisplay, GridSelectionMode, GridSelectionType, GridUiActionType, GridViewDescriptorKindEnum, HighlightPipe, IS_ASYNC_PARAM_NAME, IconPosition, ImageResourceKindEnum, InvalidSmartlinkComponent, LayoutDirection, LinkTargetEnum, MAP_ENGINE, MapEngine, MenuOpenDirection, MenuTriggerType, MessageOptionType, MessageTextType, MessageType, NAMED_VALIDATOR, NamedValidatorOperationEnum, NamedValidatorService, NoPermissionPageComponent, PageExportFieldScope, PageExportSelectionKind, PageExportValueType, PageExportValuesSource, REUSE_ROUTER_SLOT_COMPONENT, ROOT_CONTAINER_UUID, ROUTER_SLOT_ID, RecordingUploaderPropertiesOpenDirectionEnum, SMART_DATE_FORMATS, SMART_DEFAULT_VIEW_COMPONENTS, SMART_NG_CLIENT_CONFIG, SMART_ROW_LAYOUT_COMPONENT, SearchPageComponent, SelectionDefinitionTypeEnum, SelectionDefinitionValueSetValueTypeEnum, ServerRequestType, SessionAPIS, SessionErrorBehaviour, SessionService, SmartActionHost, SmartActionType, SmartBackendBootstrapService, SmartComponent, SmartComponentApiClient, SmartComponentDetachedDirective, SmartComponentHost, SmartComponentLayoutComponent, SmartDateFnsAdapter, SmartDatePipe, SmartDateTimePipe, SmartDefaultErrorUiService, SmartDiagramComponent, SmartDialog, SmartEmbeddedSlotDirective, SmartExpandableSectionService, SmartFileEditorComponent, SmartFilterComponent, SmartFilterEditorContentComponent, SmartFilterEditorService, SmartFilterExpressionFieldComponent, SmartFilterPosition, SmartFilterType, SmartFilterWidgetComponent, SmartFormInputMode, SmartFormTextFieldButtonIconPosition, SmartFormWidgetDirection, SmartFormWidgetType, SmartFormWidgetWidth, SmartGridButtonType, SmartGridComponent, SmartGridDataLayout, SmartGridService, SmartGridType, SmartIconComponent, SmartIconService, SmartKeybindingService, SmartLayoutDef, SmartLinkChannelVariableInPath, SmartLinkMigrationStatusStatusEnum, SmartLinkUuidVariableInPath, SmartMapComponent, SmartMultiFileEditorComponent, SmartNavbarComponent, SmartNavbarService, SmartNavigationService, SmartNgClientFeatureKind, SmartService, SmartSessionService, SmartSessionTimerComponent, SmartTable, SmartTableButtonType, SmartTableHeaderPropertyType, SmartTableInterfaceTypeEnum, SmartTableOptionButtonDirection, SmartTableOrder, SmartTableType, SmartTimePipe, SmartTooltipDirective, SmartTreeComponent, SmartTreeNodeButtonType, SmartUserSettinsIconPosition, SmartValidatorName, SmartViewContextService, SmartViewRedirect, SmartVoiceRecorderComponent, SmartWidgetHintPosition, SmartWidgetHintPositionEnum, SmartdialogService, SmartfileuploaderComponent, SmartformComponent, SmartformLayoutDefinitionService, SmarttreeGenericService, SmarttreeService, SubjectSelectorComponent, ThemeService, ToggleLabelPosition, ToolbarAlignment, ToolbarAppearance, ToolbarDirection, TreeArrowPosition, TreeGridControl, USE_ADVANCED_FILTER, UiActionButtonComponent, UiActionButtonType, UiActionConfirmDialogService, UiActionDescriptorService, UiActionDialogButtonComponent, UiActionDialogType, UiActionFeedbackType, UiActionInputDialogService, UiActionInputType, UiActionService, UiActionToolbarComponent, UiActionTooltipTooltipPositionEnum, UiBadgeComponent, UiBadgeDirective, UploadWidgetType, ValidationResultPageComponent, ValueChangeMode, ViewContextRebuiltError, ViewEventHandlerViewEventTypeEnum, ViewService, ViewState, ViewType, barChart, bubbleChart, createBasicOptions, doughnutChart, formatChord, hasGroupEditActions, horizontalBarChart, horizontalStackedBarChart, injectSmartComponent, isMacPlatform, matches, multiAxisLineChart, parseChord, pieChart, polarAreaChart, provideSmartNgClient, radarChart, registerSmartWidget, resolveDateLocale, resolveSlot, resolveSmartNgClientConfig, resolveViewHandler, scatterChart, stackedBarChart, transformDataToBarLikeDataSet, transformDataToBasicDataSets, transformDataToBubble, transformDataToScatter, withSmartDiagram, withSmartMap };
+export { ACLEntry, APIS$5 as APIS, AclEditingViewComponent, ApiModule$4 as ApiModule, ApiQueueService, BASE_PATH$7 as BASE_PATH, COLLECTION_FORMATS$7 as COLLECTION_FORMATS, CUSTOM_DIAGRAM_OPTIONS, CloseResult, ComponentFactoryService, ComponentType, ComponentWidgetType, Configuration$7 as Configuration, DEFAULT_ROW_LAYOUT, DIALOG_DISABLE_CLOSE, DataChangeKind, DefaultChartOptionsProvider, DefaultUiActionCode_CLOSE, DrawTime, EMPTY_PARAMS, ExpandableSectionButtonIconPosition, ExpandableSectionButtonType, ExpandableSectionComponent, FilterExpressionBoolOperator$1 as FilterExpressionBoolOperator, FilterExpressionBuilderGroupBuilderGroupKindEnum, FilterExpressionBuilderUiModelTypeEnum, FilterExpressionDataType, FilterExpressionFieldWidgetType, FilterExpressionOperation, FilterExpressionOrderByOrderEnum, GenericPageComponent, GeoMapDataLoadingMode, GeoMapDataSourceType, GeoMapItemKind, GeoMapOperationMode, GeoMapSelectionMode, GeoMapTextType, GridColumnContentType, GridDataAccessConfigKindEnum, GridDefaultRowActionTrigger, GridRowStateDisplay, GridSelectionMode, GridSelectionType, GridUiActionType, GridViewDescriptorKindEnum, HighlightPipe, IS_ASYNC_PARAM_NAME, IconPosition, ImageResourceKindEnum, InvalidSmartlinkComponent, LayoutDirection, LinkTargetEnum, MAP_ENGINE, MapEngine, MenuOpenDirection, MenuTriggerType, MessageOptionType, MessageTextType, MessageType, NAMED_VALIDATOR, NamedValidatorOperationEnum, NamedValidatorService, NoPermissionPageComponent, PageExportFieldScope, PageExportSelectionKind, PageExportValueType, PageExportValuesSource, REUSE_ROUTER_SLOT_COMPONENT, ROOT_CONTAINER_UUID, ROUTER_SLOT_ID, RecordingUploaderPropertiesOpenDirectionEnum, SMART_DATE_FORMATS, SMART_DEFAULT_VIEW_COMPONENTS, SMART_NG_CLIENT_CONFIG, SMART_ROW_LAYOUT_COMPONENT, SearchPageComponent, SelectionDefinitionTypeEnum, SelectionDefinitionValueSetValueTypeEnum, ServerRequestType, SessionAPIS, SessionErrorBehaviour, SessionService, SmartActionHost, SmartActionType, SmartBackendBootstrapService, SmartComponent, SmartComponentApiClient, SmartComponentDetachedDirective, SmartComponentHost, SmartComponentLayoutComponent, SmartDateFnsAdapter, SmartDatePipe, SmartDateTimePipe, SmartDefaultErrorUiService, SmartDiagramComponent, SmartDialog, SmartEmbeddedSlotDirective, SmartExpandableSectionService, SmartFileEditorComponent, SmartFilterComponent, SmartFilterEditorContentComponent, SmartFilterEditorService, SmartFilterExpressionFieldComponent, SmartFilterPosition, SmartFilterType, SmartFilterWidgetComponent, SmartFormInputMode, SmartFormTextFieldButtonIconPosition, SmartFormWidgetDirection, SmartFormWidgetType, SmartFormWidgetWidth, SmartGridButtonType, SmartGridComponent, SmartGridDataLayout, SmartGridService, SmartGridType, SmartIconComponent, SmartIconService, SmartKeybindingService, SmartLayoutDef, SmartLinkChannelVariableInPath, SmartLinkMigrationStatusStatusEnum, SmartLinkUuidVariableInPath, SmartMapComponent, SmartMultiFileEditorComponent, SmartNavbarComponent, SmartNavbarService, SmartNavigationService, SmartNgClientFeatureKind, SmartService, SmartSessionService, SmartSessionTimerComponent, SmartTable, SmartTableButtonType, SmartTableHeaderPropertyType, SmartTableInterfaceTypeEnum, SmartTableOptionButtonDirection, SmartTableOrder, SmartTableType, SmartTimePipe, SmartTooltipDirective, SmartTreeComponent, SmartTreeNodeButtonType, SmartUserSettinsIconPosition, SmartValidatorName, SmartValueSetStore, SmartViewContextService, SmartViewRedirect, SmartVoiceRecorderComponent, SmartWidgetHintPosition, SmartWidgetHintPositionEnum, SmartdialogService, SmartfileuploaderComponent, SmartformComponent, SmartformLayoutDefinitionService, SmarttreeGenericService, SmarttreeService, SubjectSelectorComponent, ThemeService, ToggleLabelPosition, ToolbarAlignment, ToolbarAppearance, ToolbarDirection, TreeArrowPosition, TreeGridControl, USE_ADVANCED_FILTER, UiActionButtonComponent, UiActionButtonType, UiActionConfirmDialogService, UiActionDescriptorService, UiActionDialogButtonComponent, UiActionDialogType, UiActionFeedbackType, UiActionInputDialogService, UiActionInputType, UiActionService, UiActionToolbarComponent, UiActionTooltipTooltipPositionEnum, UiBadgeComponent, UiBadgeDirective, UploadWidgetType, ValidationResultPageComponent, ValueChangeMode, ViewContextRebuiltError, ViewEventHandlerViewEventTypeEnum, ViewService, ViewState, ViewType, barChart, bubbleChart, createBasicOptions, doughnutChart, formatChord, hasGroupEditActions, horizontalBarChart, horizontalStackedBarChart, injectSmartComponent, isMacPlatform, matches, multiAxisLineChart, parseChord, pieChart, polarAreaChart, provideSmartNgClient, radarChart, registerSmartWidget, resolveDateLocale, resolveSlot, resolveSmartNgClientConfig, resolveViewHandler, scatterChart, stackedBarChart, transformDataToBarLikeDataSet, transformDataToBasicDataSets, transformDataToBubble, transformDataToScatter, withSmartDiagram, withSmartMap };
 //# sourceMappingURL=smartbit4all-ng-client.mjs.map