@stemy/ngx-utils 19.5.26 → 19.6.1

package/fesm2022/stemy-ngx-utils.mjs

@@ -1,10 +1,10 @@
 import 'zone.js';
 import 'reflect-metadata';
 import * as i0 from '@angular/core';
-import { InjectionToken, PLATFORM_ID, Inject, Injectable, Optional, Injector, untracked, computed, signal, inject, DestroyRef, EventEmitter, isDevMode, ErrorHandler, createComponent, NgZone, Pipe, input, output, ChangeDetectorRef, ElementRef, effect, HostListener, Directive, Input, HostBinding, Output, TemplateRef, ChangeDetectionStrategy, ViewEncapsulation, Component, ViewChild, forwardRef, ContentChild, ContentChildren, model, contentChildren, APP_INITIALIZER, makeEnvironmentProviders, NgModule } from '@angular/core';
+import { InjectionToken, PLATFORM_ID, Inject, Injectable, Optional, Injector, untracked, computed, signal, inject, DestroyRef, isDevMode, ErrorHandler, EventEmitter, createComponent, NgZone, Pipe, input, output, ChangeDetectorRef, ElementRef, effect, HostListener, Directive, Input, HostBinding, Output, TemplateRef, ChangeDetectionStrategy, ViewEncapsulation, Component, ViewChild, forwardRef, ContentChild, ContentChildren, model, contentChildren, APP_INITIALIZER, makeEnvironmentProviders, NgModule } from '@angular/core';
 import * as i2 from '@angular/router';
 import { ActivatedRouteSnapshot, Scroll, NavigationEnd, Router, DefaultUrlSerializer, UrlTree, UrlSegmentGroup, UrlSegment, UrlSerializer, ROUTES } from '@angular/router';
-import { BehaviorSubject, Observable, firstValueFrom, Subject, Subscription, from, TimeoutError, combineLatest, lastValueFrom } from 'rxjs';
+import { BehaviorSubject, Observable, firstValueFrom, Subject, Subscription, from, delay, timer, TimeoutError, combineLatest, lastValueFrom } from 'rxjs';
 import { skipWhile, debounceTime, distinctUntilChanged, map, filter, mergeMap, timeout } from 'rxjs/operators';
 import * as i1$3 from '@angular/common';
 import { isPlatformBrowser, isPlatformServer, DOCUMENT, APP_BASE_HREF, CommonModule } from '@angular/common';
@@ -13,7 +13,7 @@ import { DeviceDetectorService } from 'ngx-device-detector';
 import { DateTime } from 'luxon';
 import { Invokable } from 'invokable';
 import * as i1$1 from '@angular/common/http';
-import { HttpClient, HttpHeaders, HttpParams, HttpUrlEncodingCodec, HttpEventType } from '@angular/common/http';
+import { HttpClient, HttpHeaders, HttpParams, HttpUrlEncodingCodec, HttpEventType, HttpResponse } from '@angular/common/http';
 import JSON5 from 'json5';
 import * as i1$2 from '@angular/platform-browser';
 import { ɵDomEventsPlugin as _DomEventsPlugin, EVENT_MANAGER_PLUGINS } from '@angular/platform-browser';
@@ -224,6 +224,9 @@ class ObjectUtils {
     static isString(value) {
         return typeof value === "string";
     }
+    static isStringWithValue(value) {
+        return ObjectUtils.isString(value) && value.length > 0;
+    }
     static isFunction(value) {
         return typeof value === "function";
     }
@@ -448,30 +451,6 @@ class PaginationItemContext {
         return false;
     }
 }
-class HttpPromise extends Promise {
-    constructor(rejectHandler, executor) {
-        super(executor);
-        this.rejectHandler = rejectHandler;
-        this.attachCount = 0;
-        this.runCount = 0;
-    }
-    then(onFulfilled, onRejected) {
-        this.attachCount++;
-        return super.then(value => {
-            this.runCount++;
-            return onFulfilled ? onFulfilled(value) : null;
-        }, (reason) => {
-            const result = onRejected ? onRejected(reason) : null;
-            this.hasRejectHandler = this.hasRejectHandler || (onRejected && result !== false);
-            this.runCount++;
-            this.rejectHandler(this.runCount == this.attachCount && !this.hasRejectHandler ? reason : null);
-            return result;
-        });
-    }
-    catch(onRejected) {
-        return this.then(null, onRejected);
-    }
-}
 // --- Resource if ---
 class ResourceIfContext {
 }
@@ -2038,6 +2017,21 @@ class MathUtils {
 function isBrowser() {
     return typeof window !== "undefined";
 }
+/**
+ * Returns a hash code from anything
+ * @param  {string} obj The object to hash.
+ * @return {number} A 32bit integer
+ */
+function hashCode(obj) {
+    const str = typeof obj === "string" ? obj : JSON.stringify(obj);
+    let hash = 0;
+    for (let i = 0, len = str.length; i < len; i++) {
+        const chr = str.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}
 function switchClass(elem, className, status) {
     if (!elem?.classList)
         return;
@@ -2319,21 +2313,6 @@ class StringUtils {
         }
     }
 }
-/**
- * Returns a hash code from a string
- * @param  {String} str The string to hash.
- * @return {Number}    A 32bit integer
- * @see http://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
- */
-function hashCode(str) {
-    let hash = 0;
-    for (let i = 0, len = str.length; i < len; i++) {
-        const chr = str.charCodeAt(i);
-        hash = (hash << 5) - hash + chr;
-        hash |= 0; // Convert to 32bit integer
-    }
-    return hash;
-}
 
 class SetUtils {
     static equals(set, obj) {
@@ -2850,6 +2829,78 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
             type: Injectable
         }], ctorParameters: () => [{ type: UniversalService }] });
 
+class EventsService {
+    get isSticky() {
+        return this.sticky;
+    }
+    get isAuthenticated() {
+        return !!this.user;
+    }
+    constructor() {
+        this.eventForwarded = new Subject();
+        this.stickyUpdated = new Subject();
+        this.languageChanged = new Subject();
+        this.translationsEnabled = new Subject();
+        this.userChanged = new Subject();
+        this.sticky = false;
+        this.user = null;
+        this.userChanged.subscribe(user => {
+            this.user = user;
+        });
+    }
+    event(e) {
+        this.eventForwarded.next(e);
+    }
+    updateSticky(sticky) {
+        this.sticky = sticky;
+        this.stickyUpdated.next(sticky);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: EventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: EventsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: EventsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class CacheService {
+    get userChanged() {
+        return this.events.userChanged;
+    }
+    constructor(events) {
+        this.events = events;
+        this.ignore = new BehaviorSubject(null).pipe(delay(5));
+        this.permanent = new Subject();
+        this.caches = new Map();
+    }
+    expiresIn(amount = 10, unit = "seconds") {
+        const when = DateTime.now().plus({ [unit]: amount }).toJSDate();
+        return this.expiresAt(when);
+    }
+    expiresAt(when) {
+        const now = new Date().getTime();
+        // Prevent negative delay
+        const delay = Math.max(when.getTime() - now, 5);
+        return timer(delay);
+    }
+    use(key, valueCb, expires) {
+        if (this.caches.has(key)) {
+            return this.caches.get(key);
+        }
+        const value = valueCb();
+        this.caches.set(key, value);
+        const subscription = (expires || this.permanent).subscribe(() => {
+            this.caches.delete(key);
+            subscription.unsubscribe();
+        });
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CacheService, deps: [{ token: EventsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CacheService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CacheService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: EventsService }] });
+
 class BaseHttpService {
     static { this.failedRequests = []; }
     get name() {
@@ -2865,21 +2916,30 @@ class BaseHttpService {
     get universal() {
         return this.storage.universal;
     }
-    constructor(injector, client, storage, language, toaster, configs, request = null) {
+    constructor(injector, client, storage, caches, language, toaster, configs, request = null) {
         this.injector = injector;
         this.client = client;
         this.storage = storage;
+        this.caches = caches;
         this.language = language;
         this.toaster = toaster;
         this.configs = configs;
         this.request = request;
         this.requestHeaders = {};
         this.requestParams = {};
-        this.cache = {};
         this.initService();
     }
     initService() {
     }
+    cached(mode) {
+        if (mode === "auth") {
+            return this.caches.userChanged;
+        }
+        if (mode instanceof Date) {
+            return this.caches.expiresAt(mode);
+        }
+        return mode === false ? this.caches.ignore : this.caches.permanent;
+    }
     url(url) {
         return url;
     }
@@ -2986,78 +3046,84 @@ class BaseHttpService {
     toastError(message, issueContext, reason, options) {
         this.toaster.warning(message, { issueContext, reason, options });
     }
-    toPromise(url, options, listener) {
-        const issueContext = { url: "" };
-        return new HttpPromise(response => {
-            if (!response) {
-                if (this.universal.isServer)
+    toPromise(url, requestOptions, listener) {
+        const { cache, read, ...options } = requestOptions;
+        const absoluteUrl = this.absoluteUrl(url, options);
+        const cacheKey = `request-${hashCode(absoluteUrl)}-${hashCode(options)}`;
+        const issueContext = { url: absoluteUrl };
+        return this.caches.use(`${cacheKey}-${read}`, async () => {
+            const response = await this.caches.use(cacheKey, () => new HttpPromise(response => {
+                if (!response) {
+                    if (this.universal.isServer)
+                        return;
+                    console.log("You may not need a reject Handler for this request!", this.name, url, options);
                     return;
-                console.log("You may not need a reject Handler for this request!", this.name, url, options);
-                return;
-            }
-            const reason = response.error || {};
-            if (response.status == 0 || response.status == 301) {
-                this.toastWarning(`${url} endpoint is not implemented! Click here, to quickly create an issue.`, issueContext, reason, options);
-                return;
-            }
-            const regex = /((E11000 duplicate key error collection: (.)+\.)|(_1 dup key:(.)+))/g;
-            if (reason.message && regex.test(reason.message)) {
-                this.toastError("message.duplicate-key.error." + reason.message.replace(regex, "").replace(" index: ", "-"), issueContext, reason, options);
-                return;
-            }
-            this.toastWarning(`${url} endpoint error is not handled properly! Click here, to quickly create an issue.`, issueContext, reason, options);
-        }, (resolve, reject) => {
-            this.absoluteUrl(url, options).then(absoluteUrl => {
-                issueContext.url = absoluteUrl;
+                }
+                const reason = response.error || {};
+                if (response.status == 0 || response.status == 301) {
+                    this.toastWarning(`${url} endpoint is not implemented! Click here, to quickly create an issue.`, issueContext, reason, options);
+                    return;
+                }
+                const regex = /((E11000 duplicate key error collection: (.)+\.)|(_1 dup key:(.)+))/g;
+                if (reason.message && regex.test(reason.message)) {
+                    this.toastError("message.duplicate-key.error." + reason.message.replace(regex, "").replace(" index: ", "-"), issueContext, reason, options);
+                    return;
+                }
+                this.toastWarning(`${url} endpoint error is not handled properly! Click here, to quickly create an issue.`, issueContext, reason, options);
+            }, (resolve, reject) => {
                 const request = this.client.request(options.method, absoluteUrl, options);
                 const finalRequest = ObjectUtils.isNumber(options.timeout) && options.timeout > 0
                     ? request.pipe(timeout(options.timeout)) : request;
-                finalRequest.subscribe((event) => {
-                    if (options.reportProgress && event?.type === HttpEventType.UploadProgress) {
-                        const progress = {
-                            percentage: MathUtils.round(event.loaded / event.total, 2, 0.01),
-                            loaded: event.loaded,
-                            total: event.total
-                        };
-                        if (listener) {
-                            listener(progress);
+                finalRequest.subscribe({
+                    next: event => {
+                        if (options.reportProgress && event?.type === HttpEventType.UploadProgress) {
+                            const progress = {
+                                percentage: MathUtils.round(event.loaded / event.total, 2, 0.01),
+                                loaded: event.loaded,
+                                total: event.total
+                            };
+                            if (listener) {
+                                listener(progress);
+                            }
+                            return;
                         }
-                        return;
-                    }
-                    resolve(this.parseResponse(event, url, options));
-                    const headers = options.headers;
-                    const authKey = "Authorization";
-                    // If we use token auth
-                    if (this.client.renewTokenFunc && headers.has(authKey)) {
-                        const currentTime = Date.now() + 60_000;
-                        const userTokenTime = this.getUserTokenTime() || currentTime;
-                        // And the stored token expiration time is almost ended
-                        if (currentTime >= userTokenTime) {
-                            this.client.renewTokenFunc();
+                        resolve(event);
+                        const headers = options.headers;
+                        const authKey = "Authorization";
+                        // If we use token auth
+                        if (this.client.renewTokenFunc && headers.has(authKey)) {
+                            const currentTime = Date.now() + 60_000;
+                            const userTokenTime = this.getUserTokenTime() || currentTime;
+                            // And the stored token expiration time is almost ended
+                            if (currentTime >= userTokenTime) {
+                                this.client.renewTokenFunc();
+                            }
                         }
-                    }
-                }, (response) => {
-                    if (response instanceof TimeoutError || response.status == 0 || response.status == 301) {
-                        reject(response);
-                        return;
-                    }
-                    const headers = options.headers;
-                    const authKey = "Authorization";
-                    // If an authorization header exists, and we still have an Unauthorized response prompt the user to log in again
-                    if (headers.has(authKey) && response.status == 401) {
-                        const pushed = this.pushFailedRequest(url, options, () => {
-                            options.headers = this.makeHeaders(options.originalHeaders);
-                            this.toPromise(url, options, listener).then(resolve, reject);
-                        });
-                        if (pushed) {
-                            this.handleUnauthorizedError(absoluteUrl, options, () => reject(response));
+                    },
+                    error: (response) => {
+                        if (response instanceof TimeoutError || response.status == 0 || response.status == 301) {
+                            reject(response);
                             return;
                         }
+                        const headers = options.headers;
+                        const authKey = "Authorization";
+                        // If an authorization header exists, and we still have an Unauthorized response prompt the user to log in again
+                        if (headers.has(authKey) && response.status == 401) {
+                            const pushed = this.pushFailedRequest(url, options, () => {
+                                options.headers = this.makeHeaders(options.originalHeaders);
+                                this.toPromise(url, options, listener).then(resolve, reject);
+                            });
+                            if (pushed) {
+                                this.handleUnauthorizedError(absoluteUrl, options, () => reject(response));
+                                return;
+                            }
+                        }
+                        reject(response);
                     }
-                    reject(response);
                 });
-            });
-        });
+            }), cache);
+            return this.parseResponse(response, url, options, read);
+        }, cache);
     }
     getUserTokenTime() {
         return this.storage.get("userTokenTime");
@@ -3074,9 +3140,10 @@ class BaseHttpService {
         }
         return headers.referer.indexOf(headers.host) >= 0;
     }
-    makeOptions(options, method = "GET", body) {
+    makeOptions(options, method = "GET", body, cache) {
         // Set base options
         options = options ? { ...options } : {};
+        options.cache = options.cache || cache || this.caches.ignore;
         options.method = method;
         options.observe = options.observe || "body";
         options.originalHeaders = options.originalHeaders || options.headers || {};
@@ -3097,13 +3164,18 @@ class BaseHttpService {
     makeParams(options) {
         return this.client.makeParams(Object.assign({}, this.requestParams, options?.params || {}));
     }
-    parseResponse(response, url, options) {
-        return response;
+    parseResponse(response, url, options, read) {
+        if (!read)
+            return response;
+        if (response instanceof HttpResponse) {
+            response = response.body;
+        }
+        return ObjectUtils.isObject(response) ? response[read] : response;
     }
     parseUrl(url) {
         return this.url(url).replace(/(?:((?!:).\/)\/)/g, "$1");
     }
-    async absoluteUrl(url, options) {
+    absoluteUrl(url, options) {
         return this.parseUrl(url);
     }
     expressRequestUrl(url) {
@@ -3113,21 +3185,12 @@ class BaseHttpService {
         const separator = url.startsWith("/") ? "" : "/";
         return `${req.protocol}://${req.get("host")}${separator}${url}`;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BaseHttpService, deps: [{ token: Injector }, { token: BaseHttpClient }, { token: StorageService }, { token: LANGUAGE_SERVICE }, { token: TOASTER_SERVICE }, { token: CONFIG_SERVICE }, { token: EXPRESS_REQUEST, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BaseHttpService, deps: [{ token: i0.Injector }, { token: BaseHttpClient }, { token: StorageService }, { token: CacheService }, { token: LANGUAGE_SERVICE }, { token: TOASTER_SERVICE }, { token: CONFIG_SERVICE }, { token: EXPRESS_REQUEST, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BaseHttpService }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BaseHttpService, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: i0.Injector, decorators: [{
-                    type: Inject,
-                    args: [Injector]
-                }] }, { type: BaseHttpClient, decorators: [{
-                    type: Inject,
-                    args: [BaseHttpClient]
-                }] }, { type: StorageService, decorators: [{
-                    type: Inject,
-                    args: [StorageService]
-                }] }, { type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: BaseHttpClient }, { type: StorageService }, { type: CacheService }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [LANGUAGE_SERVICE]
                 }] }, { type: undefined, decorators: [{
@@ -3142,29 +3205,57 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
                     type: Inject,
                     args: [EXPRESS_REQUEST]
                 }] }] });
+class HttpPromise extends Promise {
+    constructor(rejectHandler, executor) {
+        super(executor);
+        this.rejectHandler = rejectHandler;
+        this.attachCount = 0;
+        this.runCount = 0;
+    }
+    then(onFulfilled, onRejected) {
+        this.attachCount++;
+        return super.then(value => {
+            this.runCount++;
+            return onFulfilled ? onFulfilled(value) : null;
+        }, (reason) => {
+            const result = onRejected ? onRejected(reason) : null;
+            this.hasRejectHandler = this.hasRejectHandler || (onRejected && result !== false);
+            this.runCount++;
+            this.rejectHandler(this.runCount == this.attachCount && !this.hasRejectHandler ? reason : null);
+            return result;
+        });
+    }
+    catch(onRejected) {
+        return this.then(null, onRejected);
+    }
+}
 
 class LocalHttpService extends BaseHttpService {
     get name() {
         return "local-http";
     }
+    get config() {
+        return this.configs.config;
+    }
     get withCredentials() {
         return false;
     }
     initService() {
+        super.initService();
         this.images = {};
     }
     url(url) {
         if (!url)
             return url;
-        const config = this.configs.config;
+        const config = this.config;
         const baseUrl = config.cdnUrl || config.baseUrl || "";
         return url.startsWith("data:") || url.startsWith("http") || url.startsWith("//")
             ? url
             : `${baseUrl}${url}`;
     }
-    get(url, options) {
-        this.cache[url] = this.cache[url] || this.getPromise(url, options);
-        return this.cache[url];
+    get(url, options, body) {
+        options = this.makeOptions(options, "GET", body, this.caches.permanent);
+        return this.toPromise(url, options);
     }
     getImage(url) {
         if (this.universal.isServer)
@@ -3227,12 +3318,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
 
 const emptyGuards = [];
 class AclService {
-    constructor(injector, state, auth) {
+    constructor(injector, state, events) {
         this.injector = injector;
         this.state = state;
-        this.auth = auth;
+        this.events = events;
         this.components = [];
-        this.auth.userChanged.subscribe(() => {
+        this.events.userChanged.subscribe(() => {
             this.components.forEach(t => t.dirty = true);
             const info = this.getStateInfo();
             const check = info && info.guard instanceof AuthGuard ? info.guard.checkRoute(info.route) : Promise.resolve(true);
@@ -3292,15 +3383,12 @@ class AclService {
         info.component = this.state.component;
         return info;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AclService, deps: [{ token: i0.Injector }, { token: StateService }, { token: AUTH_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AclService, deps: [{ token: i0.Injector }, { token: StateService }, { token: EventsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AclService }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AclService, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: i0.Injector }, { type: StateService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [AUTH_SERVICE]
-                }] }] });
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: StateService }, { type: EventsService }] });
 
 class ApiService extends BaseHttpService {
     get name() {
@@ -3346,16 +3434,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
         }] });
 
 class StaticAuthService {
-    constructor() {
-        this.isAuthenticated = true;
-        this.userChanged = new EventEmitter();
+    get isAuthenticated() {
+        return false;
     }
     checkAuthenticated() {
         return Promise.resolve(this.isAuthenticated);
     }
-    getReturnState(route) {
-        return null;
-    }
 }
 
 class ConfigService {
@@ -3564,31 +3648,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
             type: Injectable
         }], ctorParameters: () => [{ type: i0.Injector }] });
 
-class EventsService {
-    get isSticky() {
-        return this.sticky;
-    }
-    constructor() {
-        this.eventForwarded = new EventEmitter();
-        this.stickyUpdated = new EventEmitter();
-        this.languageChanged = new EventEmitter();
-        this.translationsEnabled = new EventEmitter();
-        this.sticky = false;
-    }
-    event(e) {
-        this.eventForwarded.emit(e);
-    }
-    updateSticky(sticky) {
-        this.sticky = sticky;
-        this.stickyUpdated.emit(sticky);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: EventsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: EventsService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: EventsService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
 class FormatterService {
     get defaultPrecision() {
         return 2;
@@ -3709,7 +3768,7 @@ class StaticLanguageService {
     }
     set currentLanguage(lang) {
         this.currentLang = lang;
-        this.events.languageChanged.emit(lang);
+        this.events.languageChanged.next(lang);
     }
     get editLanguage() {
         return this.editLang || this.currentLanguage;
@@ -3722,7 +3781,7 @@ class StaticLanguageService {
     }
     set enableTranslations(value) {
         this.enableTrans = value;
-        this.events.translationsEnabled.emit(value);
+        this.events.translationsEnabled.next(value);
     }
     get disableTranslations() {
         return !this.enableTranslations;
@@ -3878,7 +3937,7 @@ class LanguageService extends StaticLanguageService {
     }
     set currentLanguage(lang) {
         this.useLanguage(lang).then(() => {
-            this.events.languageChanged.emit(lang);
+            this.events.languageChanged.next(lang);
         });
     }
     get settings() {
@@ -3923,7 +3982,7 @@ class LanguageService extends StaticLanguageService {
         }
         const lang = this.languages.indexOf(defaultLanguage) < 0 ? settings.defaultLanguage || this.languageList[0] : defaultLanguage;
         await this.useLanguage(lang);
-        this.events.languageChanged.emit(lang);
+        this.events.languageChanged.next(lang);
     }
     async useLanguage(lang) {
         lang = this.languages.indexOf(lang) < 0 ? this.languages[0] : lang;
@@ -3977,27 +4036,74 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
 class OpenApiService {
     constructor(api) {
         this.api = api;
+        this.dynamicSchemas = {};
     }
-    getSchemas() {
-        this.schemasPromise = this.schemasPromise || new Promise((resolve => {
-            this.api.get("api-docs").then(res => {
-                const schemas = res.components?.schemas || res.definitions || {};
-                Object.values(schemas).forEach(schema => {
-                    Object.keys(schema.properties || {}).forEach(p => {
-                        schema.properties[p].id = p;
-                    });
-                });
-                resolve(schemas);
-            }, () => {
-                resolve({});
-            });
+    isDynamicSchema(value) {
+        if (!ObjectUtils.isObject(value)) {
+            return false;
+        }
+        const definition = value;
+        return ObjectUtils.isStringWithValue(definition.dynamicSchema)
+            || ObjectUtils.isStringWithValue(definition.dynamicSchemaUrl)
+            || ObjectUtils.isStringWithValue(definition.dynamicSchemaName);
+    }
+    async getSchemas() {
+        const cache = this.api.cached("auth");
+        const apiDocs = this.api.get("api-docs", { cache });
+        if (apiDocs !== this.apiDocs) {
+            this.apiDocs = apiDocs;
+            this.schemas = apiDocs.then(res => this.extractSchemas(res));
+        }
+        return this.schemas;
+    }
+    async getReferences(property, schema) {
+        const props = !property.items ? [property] : [property, property.items];
+        const references = [];
+        for (const prop of props) {
+            if (this.isDynamicSchema(prop) || ObjectUtils.isStringWithValue(prop.$ref)) {
+                references.push(prop);
+                continue;
+            }
+            if (ObjectUtils.isArray(prop.allOf)) {
+                prop.allOf
+                    .filter(ref => ObjectUtils.isStringWithValue(ref.$ref))
+                    .forEach(ref => references.push(ref));
+            }
+            if (ObjectUtils.isArray(prop.oneOf)) {
+                prop.oneOf
+                    .filter(ref => ObjectUtils.isStringWithValue(ref.$ref))
+                    .forEach(ref => references.push(ref));
+            }
+        }
+        return Promise.all(references.map(ref => {
+            if (this.isDynamicSchema(ref)) {
+                return this.getDynamicSchema(ref);
+            }
+            return this.getSchema(ref.$ref.split("/").pop());
         }));
-        return this.schemasPromise;
     }
     async getSchema(name) {
         const schemas = await this.getSchemas();
         return schemas[name] || null;
     }
+    async getDynamicSchema(definition) {
+        const cache = this.api.cached("auth");
+        const dynamicDocs = await this.api.get(definition.dynamicSchema || definition.dynamicSchemaUrl || "dynamic-schemas", { cache });
+        const dynamicSchemas = this.extractSchemas(dynamicDocs);
+        const dynamicSchema = dynamicSchemas[definition.dynamicSchemaName || "DTO"];
+        delete dynamicSchemas[definition.dynamicSchemaName || "DTO"];
+        Object.assign(this.dynamicSchemas, dynamicSchemas);
+        return dynamicSchema;
+    }
+    extractSchemas(res) {
+        const schemas = Object.assign({}, res.components?.schemas || res.definitions || {});
+        Object.values(schemas).forEach(schema => {
+            Object.keys(schema.properties || {}).forEach(p => {
+                schema.properties[p].id = p;
+            });
+        });
+        return schemas;
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: OpenApiService, deps: [{ token: API_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: OpenApiService }); }
 }
@@ -4332,10 +4438,10 @@ class SocketService {
     get id() {
         return this.client.id;
     }
-    constructor(auth, api, ioPath) {
-        this.auth = auth;
+    constructor(api, ioPath, events) {
         this.api = api;
         this.ioPath = ioPath;
+        this.events = events;
         const url = this.api.url(this.ioPath);
         this.client = new SocketClient(url, async () => {
             let script = null;
@@ -4350,23 +4456,23 @@ class SocketService {
         });
     }
     withAuth(extraHeaders = {}) {
-        this.authSub = this.auth.userChanged.subscribe(user => {
+        this.userSub = this.events.userChanged.subscribe(user => {
             if (user) {
                 this.connect(extraHeaders);
                 return;
             }
             this.disconnect();
         });
-        if (this.auth.isAuthenticated) {
+        if (this.events.isAuthenticated) {
             this.connect(extraHeaders);
         }
     }
     ngOnDestroy() {
-        this.authSub?.unsubscribe();
+        this.userSub?.unsubscribe();
         this.disconnect();
     }
     connect(extraHeaders = {}) {
-        if (this.authSub && this.auth.isAuthenticated) {
+        if (this.userSub && this.events.isAuthenticated) {
             extraHeaders = {
                 ...(extraHeaders || {}),
                 ...Object.entries(this.api.client.requestHeaders || {}).reduce((res, entry) => {
@@ -4389,21 +4495,18 @@ class SocketService {
     request(event, content) {
         return this.client.request(event, content);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SocketService, deps: [{ token: AUTH_SERVICE }, { token: API_SERVICE }, { token: SOCKET_IO_PATH }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SocketService, deps: [{ token: API_SERVICE }, { token: SOCKET_IO_PATH }, { token: EventsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SocketService }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: SocketService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [AUTH_SERVICE]
-                }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [API_SERVICE]
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [SOCKET_IO_PATH]
-                }] }] });
+                }] }, { type: EventsService }] });
 
 class DragDropHandler {
     static get(el) {
@@ -8391,6 +8494,7 @@ const providers = [
     StaticLanguageService,
     StorageService,
     BaseToasterService,
+    CacheService,
     ComponentLoaderService,
     TranslatedUrlSerializer,
     UniversalService,
@@ -8780,5 +8884,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { API_SERVICE, APP_BASE_URL, AUTH_SERVICE, AclService, AjaxRequestHandler, ApiService, ArrayUtils, AsyncMethodBase, AsyncMethodDirective, AsyncMethodTargetDirective, AuthGuard, BASE_CONFIG, BUTTON_TYPE, BackgroundDirective, BaseDialogService, BaseHttpClient, BaseHttpService, BaseToasterService, BtnComponent, BtnDefaultComponent, CONFIG_SERVICE, CanvasColor, CanvasUtils, ChipsComponent, ChunkPipe, Circle, ComponentLoaderDirective, ComponentLoaderService, ConfigService, DIALOG_SERVICE, DateUtils, DragDropEventPlugin, DropListComponent, DropdownBoxComponent, DropdownContentDirective, DropdownDirective, DropdownToggleDirective, DynamicTableComponent, DynamicTableTemplateDirective, ERROR_HANDLER, EXPRESS_REQUEST, EntriesPipe, ErrorHandlerService, EventsService, ExtraItemPropertiesPipe, FactoryDependencies, FakeModuleComponent, FileSystemEntry, FileUtils, FilterPipe, FindPipe, ForbiddenZone, FormatNumberPipe, FormatterService, GenericValue, GetOffsetPipe, GetTypePipe, GetValuePipe, GlobalTemplateDirective, GlobalTemplatePipe, GlobalTemplateService, GroupByPipe, HttpPromise, ICON_MAP, ICON_SERVICE, ICON_TYPE, IConfiguration, IconComponent, IconDefaultComponent, IconDirective, IconService, IncludesPipe, Initializer, InteractiveCanvasComponent, InteractiveCircleComponent, InteractiveItemComponent, InteractiveRectComponent, IsTypePipe, JSONfn, JoinPipe, KeysPipe, LANGUAGE_SERVICE, LanguageService, LoaderUtils, LocalHttpService, MapPipe, MathUtils, MaxPipe, MinPipe, NgxTemplateOutletDirective, NgxUtilsModule, OPTIONS_TOKEN, ObjectType, ObjectUtils, ObservableUtils, OpenApiService, PROMISE_SERVICE, PaginationDirective, PaginationItemContext, PaginationItemDirective, PaginationMenuComponent, Point, PopPipe, PromiseService, RESIZE_DELAY, RESIZE_STRATEGY, ROOT_ELEMENT, Rect, ReducePipe, ReflectUtils, RemapPipe, ReplacePipe, ResizeEventPlugin, ResourceIfContext, ResourceIfDirective, ReversePipe, RoundPipe, SCRIPT_PARAMS, SafeHtmlPipe, ScrollEventPlugin, SetUtils, ShiftPipe, SocketClient, SocketService, SplitPipe, StateService, StaticAuthService, StaticLanguageService, StickyClassDirective, StickyDirective, StorageMode, StorageService, StringUtils, TOASTER_SERVICE, TabsComponent, TabsItemDirective, TabsTemplateDirective, TimerUtils, TranslatePipe, TranslatedUrlSerializer, UniqueUtils, UniversalService, UnorderedListComponent, UnorderedListItemDirective, UnorderedListTemplateDirective, UploadComponent, ValuedPromise, ValuesPipe, Vector, WASI_IMPLEMENTATION, WasmService, cachedFactory, cancelablePromise, checkTransitions, computedPrevious, cssStyles, cssVariables, getComponentDef, getCssVariables, hashCode, impatientPromise, isBrowser, parseSelector, provideEntryComponents, provideWithOptions, selectorMatchesList, switchClass };
+export { API_SERVICE, APP_BASE_URL, AUTH_SERVICE, AclService, AjaxRequestHandler, ApiService, ArrayUtils, AsyncMethodBase, AsyncMethodDirective, AsyncMethodTargetDirective, AuthGuard, BASE_CONFIG, BUTTON_TYPE, BackgroundDirective, BaseDialogService, BaseHttpClient, BaseHttpService, BaseToasterService, BtnComponent, BtnDefaultComponent, CONFIG_SERVICE, CacheService, CanvasColor, CanvasUtils, ChipsComponent, ChunkPipe, Circle, ComponentLoaderDirective, ComponentLoaderService, ConfigService, DIALOG_SERVICE, DateUtils, DragDropEventPlugin, DropListComponent, DropdownBoxComponent, DropdownContentDirective, DropdownDirective, DropdownToggleDirective, DynamicTableComponent, DynamicTableTemplateDirective, ERROR_HANDLER, EXPRESS_REQUEST, EntriesPipe, ErrorHandlerService, EventsService, ExtraItemPropertiesPipe, FactoryDependencies, FakeModuleComponent, FileSystemEntry, FileUtils, FilterPipe, FindPipe, ForbiddenZone, FormatNumberPipe, FormatterService, GenericValue, GetOffsetPipe, GetTypePipe, GetValuePipe, GlobalTemplateDirective, GlobalTemplatePipe, GlobalTemplateService, GroupByPipe, ICON_MAP, ICON_SERVICE, ICON_TYPE, IConfiguration, IconComponent, IconDefaultComponent, IconDirective, IconService, IncludesPipe, Initializer, InteractiveCanvasComponent, InteractiveCircleComponent, InteractiveItemComponent, InteractiveRectComponent, IsTypePipe, JSONfn, JoinPipe, KeysPipe, LANGUAGE_SERVICE, LanguageService, LoaderUtils, LocalHttpService, MapPipe, MathUtils, MaxPipe, MinPipe, NgxTemplateOutletDirective, NgxUtilsModule, OPTIONS_TOKEN, ObjectType, ObjectUtils, ObservableUtils, OpenApiService, PROMISE_SERVICE, PaginationDirective, PaginationItemContext, PaginationItemDirective, PaginationMenuComponent, Point, PopPipe, PromiseService, RESIZE_DELAY, RESIZE_STRATEGY, ROOT_ELEMENT, Rect, ReducePipe, ReflectUtils, RemapPipe, ReplacePipe, ResizeEventPlugin, ResourceIfContext, ResourceIfDirective, ReversePipe, RoundPipe, SCRIPT_PARAMS, SafeHtmlPipe, ScrollEventPlugin, SetUtils, ShiftPipe, SocketClient, SocketService, SplitPipe, StateService, StaticAuthService, StaticLanguageService, StickyClassDirective, StickyDirective, StorageMode, StorageService, StringUtils, TOASTER_SERVICE, TabsComponent, TabsItemDirective, TabsTemplateDirective, TimerUtils, TranslatePipe, TranslatedUrlSerializer, UniqueUtils, UniversalService, UnorderedListComponent, UnorderedListItemDirective, UnorderedListTemplateDirective, UploadComponent, ValuedPromise, ValuesPipe, Vector, WASI_IMPLEMENTATION, WasmService, cachedFactory, cancelablePromise, checkTransitions, computedPrevious, cssStyles, cssVariables, getComponentDef, getCssVariables, hashCode, impatientPromise, isBrowser, parseSelector, provideEntryComponents, provideWithOptions, selectorMatchesList, switchClass };
 //# sourceMappingURL=stemy-ngx-utils.mjs.map