@stemy/ngx-utils 19.5.26 → 19.6.1

package/ngx-utils/common-types.d.ts

@@ -1,6 +1,7 @@
 import { ElementRef, EventEmitter, InjectionToken, Injector, NgZone, Provider, TemplateRef, Type } from "@angular/core";
-import { HttpClient, HttpErrorResponse, HttpHeaders } from "@angular/common/http";
+import { HttpClient, HttpHeaders } from "@angular/common/http";
 import { ActivatedRouteSnapshot, Data, LoadChildrenCallback, Route, Routes, UrlTree } from "@angular/router";
+import { Observable } from "rxjs";
 import { DurationLikeObject } from "luxon";
 import { StringKeys } from "./helper-types";
 export type DurationUnit = StringKeys<DurationLikeObject>;
@@ -66,9 +67,14 @@ export interface ILanguageService {
     getTranslationFromObject(translations: ITranslations, params?: any, lang?: string): string;
     getTranslationFromArray(translations: ITranslation[], params?: any, lang?: string): string;
 }
+export interface IUserData {
+    _id?: string;
+    id?: string;
+    email?: string;
+    [key: string]: any;
+}
 export interface IAuthService {
-    isAuthenticated: boolean;
-    userChanged: EventEmitter<any>;
+    readonly isAuthenticated: boolean;
     checkAuthenticated(): Promise<boolean>;
 }
 export type RouteValidator = (auth: IAuthService, route?: IRoute, next?: ActivatedRouteSnapshot) => Promise<boolean>;
@@ -338,24 +344,50 @@ export interface InteractiveCanvasPointer {
     clientX: number;
     clientY: number;
 }
-export interface IHttpHeaders {
+export interface HttpRequestHeaders {
     [header: string]: string | string[];
 }
-export interface IHttpParams {
+export interface HttpRequestQuery {
     [key: string]: any;
 }
-export interface IRequestOptions {
+/**
+ * Base http request options that get sent to backend
+ */
+export interface HttpClientRequestOptions {
     method?: string;
     body?: any;
-    headers?: IHttpHeaders | HttpHeaders;
-    originalHeaders?: IHttpHeaders;
-    params?: IHttpParams;
+    headers?: HttpRequestHeaders | HttpHeaders;
+    originalHeaders?: HttpRequestHeaders;
+    params?: HttpRequestQuery;
     observe?: "body" | "response";
+    /**
+     * Used for uploads
+     */
     reportProgress?: boolean;
+    /**
+     * Specifies the type of response
+     */
     responseType?: "arraybuffer" | "blob" | "json" | "text";
     withCredentials?: boolean;
     timeout?: number;
 }
+/**
+ * Extended http request options that the consumer can use
+ */
+export interface HttpRequestOptions extends HttpClientRequestOptions {
+    /**
+     * Read a specific property from the body if observe equals to 'body' and responseType equals to 'json'
+     */
+    read?: string;
+    /**
+     * Specifies when the cache for the request expires as an Observable
+     */
+    cache?: Observable<any>;
+}
+/**
+ * Defines the type of uploadable content
+ */
+export type UploadData = Record<string, any> | ArrayBuffer | FormData;
 export interface IIssueContext {
     url: string;
 }
@@ -365,58 +397,55 @@ export interface IProgress {
     total?: number;
 }
 export type ProgressListener = (progress: IProgress) => void;
-export type PromiseExecutor = (resolve: (value?: any | PromiseLike<any>) => void, reject: (reason?: any) => void) => void;
-export declare class HttpPromise extends Promise<any> {
-    protected rejectHandler: (reason?: HttpErrorResponse) => void;
-    protected hasRejectHandler: boolean;
-    protected attachCount: number;
-    protected runCount: number;
-    constructor(rejectHandler: (reason?: HttpErrorResponse) => void, executor: PromiseExecutor);
-    then<TResult1, TResult2>(onFulfilled?: ((value: any) => (PromiseLike<TResult1> | TResult1)) | null | undefined, onRejected?: ((reason: HttpErrorResponse) => (PromiseLike<TResult2> | TResult2)) | null | undefined): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onRejected?: ((reason: HttpErrorResponse) => (PromiseLike<TResult> | TResult)) | null | undefined): Promise<any | TResult>;
-}
+export type CacheExpireMode = boolean | "auth" | Date;
 export interface IHttpService {
     language: ILanguageService;
+    cached(mode: CacheExpireMode): Observable<any>;
     url(url: string): string;
-    makeListParams(page: number, itemsPerPage: number, orderBy?: string, orderDescending?: boolean, filter?: string): IHttpParams;
+    makeListParams(page: number, itemsPerPage: number, orderBy?: string, orderDescending?: boolean, filter?: string): HttpRequestQuery;
 }
 export interface IBaseHttpClient extends HttpClient {
-    readonly requestHeaders: IHttpHeaders;
-    readonly requestParams: IHttpParams;
+    readonly requestHeaders: HttpRequestHeaders;
+    readonly requestParams: HttpRequestQuery;
 }
 export interface IApiService extends IHttpService {
-    cache: any;
     client: IBaseHttpClient;
-    get(url: string, options?: IRequestOptions): Promise<any>;
-    delete(url: string, options?: IRequestOptions): Promise<any>;
-    post(url: string, body?: any, options?: IRequestOptions): Promise<any>;
-    put(url: string, body?: any, options?: IRequestOptions): Promise<any>;
-    patch(url: string, body?: any, options?: IRequestOptions): Promise<any>;
-    upload(url: string, body: any, listener?: ProgressListener, options?: IRequestOptions): Promise<any>;
-    list(url: string, params: IHttpParams, options?: IRequestOptions): Promise<IPaginationData>;
-}
-export interface IOpenApiSchemaProperty {
+    get(url: string, options?: HttpRequestOptions): Promise<any>;
+    delete(url: string, options?: HttpRequestOptions): Promise<any>;
+    post(url: string, body?: any, options?: HttpRequestOptions): Promise<any>;
+    put(url: string, body?: any, options?: HttpRequestOptions): Promise<any>;
+    patch(url: string, body?: any, options?: HttpRequestOptions): Promise<any>;
+    upload(url: string, body: any, listener?: ProgressListener, options?: HttpRequestOptions): Promise<any>;
+    list(url: string, params: HttpRequestQuery, options?: HttpRequestOptions): Promise<IPaginationData>;
+}
+export interface DynamicSchemaRef {
+    dynamicSchema?: string;
+    dynamicSchemaUrl?: string;
+    dynamicSchemaName?: string;
+}
+export interface OpenApiSchemaRef {
+    $ref?: string;
+}
+export interface OpenApiSchemaProperty extends DynamicSchemaRef, OpenApiSchemaRef {
     id: string;
     type?: string;
     format?: string;
     column?: boolean;
     additionalProperties?: any;
-    $ref?: string;
-    allOf?: ReadonlyArray<{
-        $ref?: string;
-    }>;
-    items?: IOpenApiSchemaProperty;
+    allOf?: ReadonlyArray<OpenApiSchemaRef>;
+    oneOf?: ReadonlyArray<OpenApiSchemaRef>;
+    items?: OpenApiSchemaProperty;
     enum?: string[];
     [key: string]: any;
 }
-export interface IOpenApiSchema {
+export interface OpenApiSchema {
     properties: {
-        [name: string]: IOpenApiSchemaProperty;
+        [name: string]: OpenApiSchemaProperty;
     };
     required: string[];
 }
-export interface IOpenApiSchemas {
-    [name: string]: IOpenApiSchema;
+export interface OpenApiSchemas {
+    [name: string]: OpenApiSchema;
 }
 export type TableFilterType = "text" | "enum" | "checkbox";
 export interface ITableOrders {

package/ngx-utils/ngx-utils.imports.d.ts

@@ -21,6 +21,7 @@ import { StateService } from "./services/state.service";
 import { StaticLanguageService } from "./services/static-language.service";
 import { StorageService } from "./services/storage.service";
 import { BaseToasterService } from "./services/base-toaster.service";
+import { CacheService } from "./services/cache.service";
 import { ComponentLoaderService } from "./services/component-loader.service";
 import { TranslatedUrlSerializer } from "./services/translated-url.serializer";
 import { UniversalService } from "./services/universal.service";
@@ -65,9 +66,9 @@ import { PaginationMenuComponent } from "./components/pagination-menu/pagination
 import { UnorderedListComponent } from "./components/unordered-list/unordered-list.component";
 import { UploadComponent } from "./components/upload/upload.component";
 export declare const pipes: (typeof FilterPipe | typeof FormatNumberPipe | typeof GlobalTemplatePipe | typeof IncludesPipe | typeof ReducePipe | typeof RoundPipe | typeof SafeHtmlPipe | typeof TranslatePipe)[];
-export declare const directives: (typeof TabsItemDirective | typeof AsyncMethodBase | typeof AsyncMethodTargetDirective | typeof BackgroundDirective | typeof ComponentLoaderDirective | typeof DynamicTableTemplateDirective | typeof GlobalTemplateDirective | typeof IconDirective | typeof NgxTemplateOutletDirective | typeof PaginationDirective | typeof PaginationItemDirective | typeof ResourceIfDirective | typeof StickyDirective | typeof StickyClassDirective | typeof DropdownDirective | typeof DropdownContentDirective | typeof UnorderedListItemDirective | typeof UnorderedListTemplateDirective)[];
+export declare const directives: (typeof AsyncMethodBase | typeof AsyncMethodTargetDirective | typeof BackgroundDirective | typeof ComponentLoaderDirective | typeof DynamicTableTemplateDirective | typeof GlobalTemplateDirective | typeof IconDirective | typeof NgxTemplateOutletDirective | typeof PaginationDirective | typeof PaginationItemDirective | typeof ResourceIfDirective | typeof StickyDirective | typeof StickyClassDirective | typeof DropdownDirective | typeof DropdownContentDirective | typeof TabsItemDirective | typeof UnorderedListItemDirective | typeof UnorderedListTemplateDirective)[];
 export declare const components: (typeof ChipsComponent | typeof DropListComponent | typeof DynamicTableComponent | typeof FakeModuleComponent | typeof InteractiveCanvasComponent | typeof InteractiveCircleComponent | typeof InteractiveRectComponent | typeof PaginationMenuComponent | typeof UnorderedListComponent | typeof UploadComponent)[];
-export declare const providers: (typeof UniversalService | typeof StateService | typeof AuthGuard | typeof BaseHttpClient | typeof StorageService | typeof BaseHttpService | typeof WasmService | typeof AclService | typeof StaticAuthService | typeof ConfigService | typeof BaseDialogService | typeof ErrorHandlerService | typeof EventsService | typeof FormatterService | typeof GlobalTemplateService | typeof IconService | typeof StaticLanguageService | typeof OpenApiService | typeof BaseToasterService | typeof ComponentLoaderService | typeof TranslatedUrlSerializer | typeof PromiseService | typeof SocketService | typeof FilterPipe | typeof FormatNumberPipe | typeof GlobalTemplatePipe | typeof IncludesPipe | typeof ReducePipe | typeof RoundPipe | typeof SafeHtmlPipe | typeof TranslatePipe | typeof DeviceDetectorService | {
+export declare const providers: (typeof UniversalService | typeof StateService | typeof AuthGuard | typeof BaseHttpClient | typeof StorageService | typeof EventsService | typeof CacheService | typeof BaseHttpService | typeof WasmService | typeof AclService | typeof StaticAuthService | typeof ConfigService | typeof BaseDialogService | typeof ErrorHandlerService | typeof FormatterService | typeof GlobalTemplateService | typeof IconService | typeof StaticLanguageService | typeof OpenApiService | typeof BaseToasterService | typeof ComponentLoaderService | typeof TranslatedUrlSerializer | typeof PromiseService | typeof SocketService | typeof FilterPipe | typeof FormatNumberPipe | typeof GlobalTemplatePipe | typeof IncludesPipe | typeof ReducePipe | typeof RoundPipe | typeof SafeHtmlPipe | typeof TranslatePipe | typeof DeviceDetectorService | {
     provide: import("@angular/core").InjectionToken<import("@angular/platform-browser").EventManagerPlugin[]>;
     useClass: typeof DragDropEventPlugin;
     multi: boolean;

package/ngx-utils/services/acl.service.d.ts

@@ -1,13 +1,14 @@
 import { Injector } from "@angular/core";
 import { StateService } from "./state.service";
-import { IAuthService, IRouteStateInfo } from "../common-types";
+import { IRouteStateInfo } from "../common-types";
+import { EventsService } from "./events.service";
 import * as i0 from "@angular/core";
 export declare class AclService {
     readonly injector: Injector;
     readonly state: StateService;
-    readonly auth: IAuthService;
+    readonly events: EventsService;
     protected components: IRouteStateInfo[];
-    constructor(injector: Injector, state: StateService, auth: IAuthService);
+    constructor(injector: Injector, state: StateService, events: EventsService);
     protected getStateInfo(): IRouteStateInfo;
     static ɵfac: i0.ɵɵFactoryDeclaration<AclService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AclService>;

package/ngx-utils/services/api.service.d.ts

@@ -1,17 +1,16 @@
-import { IApiService, IHttpParams, IRequestOptions, ProgressListener } from "../common-types";
+import { HttpRequestOptions, HttpRequestQuery, IApiService, IPaginationData, ProgressListener, UploadData } from "../common-types";
 import { BaseHttpService } from "./base-http.service";
-import { IPaginationData } from "../common-types";
 import * as i0 from "@angular/core";
 export declare class ApiService extends BaseHttpService implements IApiService {
     get name(): string;
     url(url: string): string;
-    get(url: string, options?: IRequestOptions, body?: any): Promise<any>;
-    delete(url: string, options?: IRequestOptions, body?: any): Promise<any>;
-    post(url: string, body?: any, options?: IRequestOptions): Promise<any>;
-    put(url: string, body?: any, options?: IRequestOptions): Promise<any>;
-    patch(url: string, body?: any, options?: IRequestOptions): Promise<any>;
-    upload(url: string, body: any, listener?: ProgressListener, options?: IRequestOptions): Promise<any>;
-    list(url: string, params: IHttpParams, options?: IRequestOptions): Promise<IPaginationData>;
+    get(url: string, options?: HttpRequestOptions, body?: any): Promise<any>;
+    delete(url: string, options?: HttpRequestOptions, body?: any): Promise<any>;
+    post(url: string, body?: any, options?: HttpRequestOptions): Promise<any>;
+    put(url: string, body?: any, options?: HttpRequestOptions): Promise<any>;
+    patch(url: string, body?: any, options?: HttpRequestOptions): Promise<any>;
+    upload(url: string, body: UploadData, listener?: ProgressListener, options?: HttpRequestOptions): Promise<any>;
+    list(url: string, params: HttpRequestQuery, options?: HttpRequestOptions): Promise<IPaginationData>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ApiService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ApiService>;
 }

package/ngx-utils/services/auth.service.d.ts

@@ -1,8 +1,5 @@
-import { EventEmitter } from "@angular/core";
-import { IRoute, IAuthService } from "../common-types";
+import { IAuthService } from "../common-types";
 export declare class StaticAuthService implements IAuthService {
-    isAuthenticated: boolean;
-    userChanged: EventEmitter<any>;
+    get isAuthenticated(): boolean;
     checkAuthenticated(): Promise<boolean>;
-    getReturnState(route: IRoute): string[];
 }

package/ngx-utils/services/base-http.client.d.ts

@@ -1,14 +1,14 @@
 import { HttpClient, HttpHandler, HttpHeaders, HttpParams } from "@angular/common/http";
-import { IHttpHeaders, IHttpParams } from "../common-types";
+import { HttpRequestHeaders, HttpRequestQuery } from "../common-types";
 import * as i0 from "@angular/core";
 export declare class BaseHttpClient extends HttpClient {
-    requestHeaders: IHttpHeaders;
-    requestParams: IHttpParams;
+    requestHeaders: HttpRequestHeaders;
+    requestParams: HttpRequestQuery;
     renewTokenFunc: () => void;
-    protected extraRequestParams: IHttpParams;
+    protected extraRequestParams: HttpRequestQuery;
     constructor(handler: HttpHandler);
-    makeHeaders(headers?: IHttpHeaders, withCredentials?: boolean): HttpHeaders;
-    makeParams(params?: IHttpParams): HttpParams;
+    makeHeaders(headers?: HttpRequestHeaders, withCredentials?: boolean): HttpHeaders;
+    makeParams(params?: HttpRequestQuery): HttpParams;
     setExtraRequestParam(name: string, value?: any): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BaseHttpClient, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BaseHttpClient>;

package/ngx-utils/services/base-http.service.d.ts

@@ -1,15 +1,18 @@
 import { Injector } from "@angular/core";
 import { HttpHeaders, HttpParams } from "@angular/common/http";
 import { Request } from "express";
-import { HttpPromise, IConfigService, IHttpHeaders, IHttpParams, IHttpService, IIssueContext, ILanguageService, IPaginationData, IRequestOptions, IToasterService, ProgressListener } from "../common-types";
+import { CacheExpireMode, IConfigService, HttpRequestHeaders, HttpRequestQuery, IHttpService, IIssueContext, ILanguageService, IPaginationData, HttpClientRequestOptions, IToasterService, ProgressListener, HttpRequestOptions, UploadData } from "../common-types";
 import { BaseHttpClient } from "./base-http.client";
 import { UniversalService } from "./universal.service";
 import { StorageService } from "./storage.service";
+import { Observable } from "rxjs";
+import { CacheService } from "./cache.service";
 import * as i0 from "@angular/core";
 export declare class BaseHttpService implements IHttpService {
     readonly injector: Injector;
     readonly client: BaseHttpClient;
     readonly storage: StorageService;
+    readonly caches: CacheService;
     readonly language: ILanguageService;
     readonly toaster: IToasterService;
     readonly configs: IConfigService;
@@ -17,37 +20,37 @@ export declare class BaseHttpService implements IHttpService {
     protected static failedRequests: Array<() => void>;
     get name(): string;
     protected get withCredentials(): boolean;
-    requestHeaders: IHttpHeaders;
-    requestParams: IHttpParams;
-    cache: any;
+    requestHeaders: HttpRequestHeaders;
+    requestParams: HttpRequestQuery;
     protected static retryFailedRequests(): void;
     get universal(): UniversalService;
-    constructor(injector: Injector, client: BaseHttpClient, storage: StorageService, language: ILanguageService, toaster: IToasterService, configs: IConfigService, request?: Request);
+    constructor(injector: Injector, client: BaseHttpClient, storage: StorageService, caches: CacheService, language: ILanguageService, toaster: IToasterService, configs: IConfigService, request?: Request);
     protected initService(): void;
+    cached(mode: CacheExpireMode): Observable<any>;
     url(url: string): string;
-    createUrl(url: string, params: IHttpParams): string;
-    makeListParams(page: number, itemsPerPage: number, orderBy?: string, orderDescending?: boolean, filter?: string): IHttpParams;
-    protected getPromise(url: string, options?: IRequestOptions, body?: any): HttpPromise;
-    protected deletePromise(url: string, options?: IRequestOptions, body?: any): HttpPromise;
-    protected postPromise(url: string, body?: any, options?: IRequestOptions): HttpPromise;
-    protected putPromise(url: string, body?: any, options?: IRequestOptions): HttpPromise;
-    protected patchPromise(url: string, body?: any, options?: IRequestOptions): HttpPromise;
-    protected uploadPromise(url: string, body: any, listener?: ProgressListener, options?: IRequestOptions): HttpPromise;
-    protected listPromise(url: string, options?: IRequestOptions): Promise<IPaginationData>;
-    protected handleUnauthorizedError(absoluteUrl: string, options: IRequestOptions, reject: () => void): void;
-    protected toastWarning(message: string, issueContext: IIssueContext, reason: any, options: IRequestOptions): void;
-    protected toastError(message: string, issueContext: IIssueContext, reason: any, options: IRequestOptions): void;
-    protected toPromise(url: string, options: IRequestOptions, listener?: ProgressListener): HttpPromise;
+    createUrl(url: string, params: HttpRequestQuery): string;
+    makeListParams(page: number, itemsPerPage: number, orderBy?: string, orderDescending?: boolean, filter?: string): HttpRequestQuery;
+    protected getPromise(url: string, options?: HttpRequestOptions, body?: any): Promise<any>;
+    protected deletePromise(url: string, options?: HttpRequestOptions, body?: any): Promise<any>;
+    protected postPromise(url: string, body?: any, options?: HttpRequestOptions): Promise<any>;
+    protected putPromise(url: string, body?: any, options?: HttpRequestOptions): Promise<any>;
+    protected patchPromise(url: string, body?: any, options?: HttpRequestOptions): Promise<any>;
+    protected uploadPromise(url: string, body: UploadData, listener?: ProgressListener, options?: HttpRequestOptions): Promise<any>;
+    protected listPromise(url: string, options?: HttpClientRequestOptions): Promise<IPaginationData>;
+    protected handleUnauthorizedError(absoluteUrl: string, options: HttpClientRequestOptions, reject: () => void): void;
+    protected toastWarning(message: string, issueContext: IIssueContext, reason: any, options: HttpClientRequestOptions): void;
+    protected toastError(message: string, issueContext: IIssueContext, reason: any, options: HttpClientRequestOptions): void;
+    protected toPromise(url: string, requestOptions: HttpRequestOptions, listener?: ProgressListener): Promise<any>;
     protected getUserTokenTime(): number;
-    protected pushFailedRequest(url: string, options: IRequestOptions, req: () => void): boolean;
+    protected pushFailedRequest(url: string, options: HttpClientRequestOptions, req: () => void): boolean;
     protected checkHeaders(headers: any): boolean;
-    protected makeOptions(options?: IRequestOptions, method?: string, body?: any): IRequestOptions;
-    protected makeHeaders(options: IRequestOptions): HttpHeaders;
-    protected makeParams(options: IRequestOptions): HttpParams;
-    protected parseResponse(response: any, url: string, options: IRequestOptions): any;
+    protected makeOptions(options?: HttpRequestOptions, method?: string, body?: any, cache?: Observable<any>): HttpClientRequestOptions;
+    protected makeHeaders(options: HttpClientRequestOptions): HttpHeaders;
+    protected makeParams(options: HttpClientRequestOptions): HttpParams;
+    protected parseResponse(response: any, url: string, options: HttpClientRequestOptions, read: string): any;
     protected parseUrl(url: string): string;
-    protected absoluteUrl(url: string, options: IRequestOptions): Promise<string>;
+    protected absoluteUrl(url: string, options: HttpClientRequestOptions): string;
     protected expressRequestUrl(url: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BaseHttpService, [null, null, null, null, null, null, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseHttpService, [null, null, null, null, null, null, null, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<BaseHttpService>;
 }

package/ngx-utils/services/cache.service.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from "rxjs";
+import { DurationUnit } from "../common-types";
+import { EventsService } from "./events.service";
+import * as i0 from "@angular/core";
+export declare class CacheService {
+    protected events: EventsService;
+    get userChanged(): Observable<any>;
+    readonly ignore: Observable<any>;
+    readonly permanent: Observable<any>;
+    private caches;
+    constructor(events: EventsService);
+    expiresIn(amount?: number, unit?: DurationUnit): Observable<any>;
+    expiresAt(when: Date): Observable<any>;
+    use<T>(key: string, valueCb: () => T, expires?: Observable<any>): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CacheService>;
+}

package/ngx-utils/services/events.service.d.ts

@@ -1,12 +1,15 @@
-import { EventEmitter } from "@angular/core";
+import { Subject } from "rxjs";
 import * as i0 from "@angular/core";
 export declare class EventsService {
-    readonly eventForwarded: EventEmitter<Event>;
-    readonly stickyUpdated: EventEmitter<boolean>;
-    readonly languageChanged: EventEmitter<string>;
-    readonly translationsEnabled: EventEmitter<boolean>;
+    readonly eventForwarded: Subject<Event>;
+    readonly stickyUpdated: Subject<boolean>;
+    readonly languageChanged: Subject<string>;
+    readonly translationsEnabled: Subject<boolean>;
+    readonly userChanged: Subject<any>;
     private sticky;
+    private user;
     get isSticky(): boolean;
+    get isAuthenticated(): boolean;
     constructor();
     event(e: Event): void;
     updateSticky(sticky: boolean): void;

package/ngx-utils/services/local-http.service.d.ts

@@ -1,13 +1,14 @@
-import { IRequestOptions } from "../common-types";
+import { HttpClientRequestOptions, IConfiguration } from "../common-types";
 import { BaseHttpService } from "./base-http.service";
 import * as i0 from "@angular/core";
 export declare class LocalHttpService extends BaseHttpService {
     private images;
     get name(): string;
+    get config(): IConfiguration;
     protected get withCredentials(): boolean;
     protected initService(): void;
     url(url: string): string;
-    get(url: string, options?: IRequestOptions): Promise<any>;
+    get(url: string, options?: HttpClientRequestOptions, body?: any): Promise<any>;
     getImage(url: string): Promise<HTMLImageElement>;
     static ɵfac: i0.ɵɵFactoryDeclaration<LocalHttpService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LocalHttpService>;

package/ngx-utils/services/open-api.service.d.ts

@@ -1,11 +1,17 @@
-import { IApiService, IOpenApiSchema, IOpenApiSchemas } from "../common-types";
+import { DynamicSchemaRef, IApiService, OpenApiSchema, OpenApiSchemaProperty, OpenApiSchemas } from "../common-types";
 import * as i0 from "@angular/core";
 export declare class OpenApiService {
     readonly api: IApiService;
-    private schemasPromise;
+    private apiDocs;
+    private schemas;
+    private readonly dynamicSchemas;
     constructor(api: IApiService);
-    getSchemas(): Promise<IOpenApiSchemas>;
-    getSchema(name: string): Promise<IOpenApiSchema>;
+    isDynamicSchema(value: any): value is Required<DynamicSchemaRef>;
+    getSchemas(): Promise<OpenApiSchemas>;
+    getReferences(property: OpenApiSchemaProperty, schema: OpenApiSchema): Promise<OpenApiSchema[]>;
+    getSchema(name: string): Promise<OpenApiSchema>;
+    protected getDynamicSchema(definition: DynamicSchemaRef): Promise<OpenApiSchema>;
+    protected extractSchemas(res: any): OpenApiSchemas;
     static ɵfac: i0.ɵɵFactoryDeclaration<OpenApiService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<OpenApiService>;
 }

package/ngx-utils/services/socket.service.d.ts

@@ -1,17 +1,18 @@
 import { OnDestroy } from "@angular/core";
 import { BehaviorSubject, Subscription } from "rxjs";
-import { IApiService, IAuthService } from "../common-types";
+import { IApiService } from "../common-types";
 import { ExtraHeaders, SocketClient, SocketData, SocketDataObj } from "../utils/socket-client";
+import { EventsService } from "./events.service";
 import * as i0 from "@angular/core";
 export declare class SocketService implements OnDestroy {
-    readonly auth: IAuthService;
     readonly api: IApiService;
     protected ioPath: string;
+    protected events: EventsService;
     protected client: SocketClient;
-    protected authSub: Subscription;
+    protected userSub: Subscription;
     get status(): BehaviorSubject<boolean>;
     get id(): string;
-    constructor(auth: IAuthService, api: IApiService, ioPath: string);
+    constructor(api: IApiService, ioPath: string, events: EventsService);
     withAuth(extraHeaders?: ExtraHeaders): void;
     ngOnDestroy(): void;
     connect(extraHeaders?: ExtraHeaders): void;

package/ngx-utils/utils/misc.d.ts

@@ -1,6 +1,12 @@
 import { Type, ValueProvider, ɵComponentDef as ComponentDef } from "@angular/core";
 import { CssSelector, CssSelectorList } from "../common-types";
 export declare function isBrowser(): boolean;
+/**
+ * Returns a hash code from anything
+ * @param  {string} obj The object to hash.
+ * @return {number} A 32bit integer
+ */
+export declare function hashCode(obj: any): number;
 export declare function switchClass(elem: HTMLElement, className: string, status?: boolean): void;
 export declare function getCssVariables(elem: HTMLElement): Record<string, string>;
 export declare function checkTransitions(el: HTMLElement, cb: () => any): void;

package/ngx-utils/utils/object.utils.d.ts

@@ -1,3 +1,4 @@
+import { MaybeArray } from "../helper-types";
 export type FilterPredicate = (value: any, key?: any, target?: any, source?: any) => boolean;
 export type IterateCallback = (value: any, key: any) => void;
 export type IterateRecursiveCallback = (value: any, key: any, path: string, obj: any) => void;
@@ -22,12 +23,13 @@ export declare class ObjectUtils {
     static isDefined(value: any): boolean;
     static isNullOrUndefined(value: any): boolean;
     static isString(value: any): value is string;
+    static isStringWithValue(value: any): value is string;
     static isFunction(value: any): value is Function;
     static isDate(value: any): value is Date;
     static isBlob(value: any): value is Blob;
     static isBoolean(value: any): value is boolean;
     static isNumber(value: any): value is number;
-    static isArray(value: any): value is Array<any>;
+    static isArray<T, U>(value: MaybeArray<T> | ReadonlyArray<T> | U): value is T[];
     static isSet(value: any): value is Set<any>;
     static isConstructor(value: any): boolean;
     static checkInterface(obj: any, interFaceObject: any): boolean;

package/ngx-utils/utils/string.utils.d.ts

@@ -7,10 +7,3 @@ export declare class StringUtils {
     static isObjectId(id: string): boolean;
     static parseDomain(baseUrl: string): string;
 }
-/**
- * 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/
- */
-export declare function hashCode(str: string): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stemy/ngx-utils",
-  "version": "19.5.26",
+  "version": "19.6.1",
   "license": "MIT",
   "public": true,
   "repository": "https://github.com/stemyke/ngx-utils.git",

package/public_api.d.ts

@@ -1,6 +1,6 @@
 import "zone.js";
 export { MaybePromise, MaybeArray, KeysOfType, ObjOfType, StringKeys, CapitalizeFirst, CamelJoin, PrefixedPick } from "./ngx-utils/helper-types";
-export { DurationUnit, TypedFactoryProvider, TypedValueProvider, CachedProvider, CachedFactory, IResolveFactory, CanvasColor, IIconService, ITranslation, ITranslations, ILanguageSetting, ILanguageSettings, ILanguageService, IAuthService, RouteValidator, IRouteData, IRoute, IAclComponent, IDialogButtonConfig, IDialogConfig, IConfirmDialogConfig, IDialogService, IPromiseService, IWasi, IWasmExports, IWasm, IWasmAsync, IRouteStateInfo, NavigationUrlParam, StorageMode, ToastType, IToasterService, IAsyncMessage, AsyncMethod, IconMap, IconProps, ButtonType, ButtonSize, ButtonProps, TabValue, TabOption, ChipValue, ChipStatus, ChipOption, DropdownAttachTo, UnorderedListTemplate, UnorderedListTemplates, UnorderedListStyle, UploadType, IFileUploadResult, IFileUploadProcess, IAjaxRequestDetails, AjaxRequestCallback, ScriptType, ILoadableElement, ILoaderPromises, ISearchObservable, FactoryDependencies, ObjectType, ITimer, IExtraProperties, IGroupMap, TranslationQuery, IPageInfo, IPaginationData, PaginationDataLoader, PaginationItemContext, IPoint, IShape, CanvasItemShape, CanvasItemDirection, InteractiveCanvas, InteractiveCanvasItem, InteractiveDrawFn, InteractivePanEvent, InteractiveCanvasPointer, IHttpHeaders, IHttpParams, IRequestOptions, IIssueContext, IProgress, ProgressListener, PromiseExecutor, HttpPromise, IHttpService, IApiService, IOpenApiSchemaProperty, IOpenApiSchema, IOpenApiSchemas, TableFilterType, ITableOrders, ITableColumn, ITableColumns, TableColumns, ITableTemplate, ITableTemplates, ITableDataQuery, TableDataLoader, DragDropEvent, DragEventHandler, ITableDragEvent, DynamicTableDragHandler, ResourceIfContext, CssSelector, CssSelectorList, DynamicComponentLocation, DynamicModuleInfo, DynamicEntryComponents, IConfiguration, IConfigService, ResizeEventStrategy, ErrorHandlerCallback, GlobalComponentModifier, AppInitializerFunc, IModuleConfig, ValuedPromise } from "./ngx-utils/common-types";
+export { DurationUnit, TypedFactoryProvider, TypedValueProvider, CachedProvider, CachedFactory, IResolveFactory, CanvasColor, IIconService, ITranslation, ITranslations, ILanguageSetting, ILanguageSettings, ILanguageService, IUserData, IAuthService, RouteValidator, IRouteData, IRoute, IAclComponent, IDialogButtonConfig, IDialogConfig, IConfirmDialogConfig, IDialogService, IPromiseService, IWasi, IWasmExports, IWasm, IWasmAsync, IRouteStateInfo, NavigationUrlParam, StorageMode, ToastType, IToasterService, IAsyncMessage, AsyncMethod, IconMap, IconProps, ButtonType, ButtonSize, ButtonProps, TabValue, TabOption, ChipValue, ChipStatus, ChipOption, DropdownAttachTo, UnorderedListTemplate, UnorderedListTemplates, UnorderedListStyle, UploadType, IFileUploadResult, IFileUploadProcess, IAjaxRequestDetails, AjaxRequestCallback, ScriptType, ILoadableElement, ILoaderPromises, ISearchObservable, FactoryDependencies, ObjectType, ITimer, IExtraProperties, IGroupMap, TranslationQuery, IPageInfo, IPaginationData, PaginationDataLoader, PaginationItemContext, IPoint, IShape, CanvasItemShape, CanvasItemDirection, InteractiveCanvas, InteractiveCanvasItem, InteractiveDrawFn, InteractivePanEvent, InteractiveCanvasPointer, HttpRequestHeaders, HttpRequestQuery, HttpClientRequestOptions, HttpRequestOptions, UploadData, IIssueContext, IProgress, ProgressListener, CacheExpireMode, IHttpService, IApiService, DynamicSchemaRef, OpenApiSchemaProperty, OpenApiSchema, OpenApiSchemas, TableFilterType, ITableOrders, ITableColumn, ITableColumns, TableColumns, ITableTemplate, ITableTemplates, ITableDataQuery, TableDataLoader, DragDropEvent, DragEventHandler, ITableDragEvent, DynamicTableDragHandler, ResourceIfContext, CssSelector, CssSelectorList, DynamicComponentLocation, DynamicModuleInfo, DynamicEntryComponents, IConfiguration, IConfigService, ResizeEventStrategy, ErrorHandlerCallback, GlobalComponentModifier, AppInitializerFunc, IModuleConfig, ValuedPromise } from "./ngx-utils/common-types";
 export { ICON_TYPE, ICON_MAP, BUTTON_TYPE, ERROR_HANDLER, RESIZE_STRATEGY, RESIZE_DELAY, ROOT_ELEMENT, SCRIPT_PARAMS, BASE_CONFIG, CONFIG_SERVICE, APP_BASE_URL, API_SERVICE, EXPRESS_REQUEST, WASI_IMPLEMENTATION, PROMISE_SERVICE, DIALOG_SERVICE, TOASTER_SERVICE, AUTH_SERVICE, LANGUAGE_SERVICE, ICON_SERVICE, OPTIONS_TOKEN } from "./ngx-utils/tokens";
 export { AjaxRequestHandler } from "./ngx-utils/utils/ajax-request-handler";
 export { ArrayUtils } from "./ngx-utils/utils/array.utils";
@@ -18,11 +18,11 @@ export { JSONfn } from "./ngx-utils/utils/jsonfn";
 export { ReflectUtils } from "./ngx-utils/utils/reflect.utils";
 export { LoaderUtils } from "./ngx-utils/utils/loader.utils";
 export { MathUtils } from "./ngx-utils/utils/math.utils";
-export { isBrowser, switchClass, getCssVariables, checkTransitions, getComponentDef, parseSelector, selectorMatchesList, provideEntryComponents } from "./ngx-utils/utils/misc";
+export { isBrowser, hashCode, switchClass, getCssVariables, checkTransitions, getComponentDef, parseSelector, selectorMatchesList, provideEntryComponents } from "./ngx-utils/utils/misc";
 export { ObjectUtils } from "./ngx-utils/utils/object.utils";
 export { ObservableUtils, ISubscriberInfo } from "./ngx-utils/utils/observable.utils";
 export { CancelablePromise, cancelablePromise, impatientPromise } from "./ngx-utils/utils/promise.utils";
-export { StringUtils, hashCode } from "./ngx-utils/utils/string.utils";
+export { StringUtils } from "./ngx-utils/utils/string.utils";
 export { SetUtils } from "./ngx-utils/utils/set.utils";
 export { computedPrevious, cssStyles, cssVariables } from "./ngx-utils/utils/signal-utils";
 export { SocketFactory, SocketData, SocketDataValue, SocketDataObj, SocketClient } from "./ngx-utils/utils/socket-client";
@@ -51,6 +51,7 @@ export { IStateInfo, StateService } from "./ngx-utils/services/state.service";
 export { StaticLanguageService } from "./ngx-utils/services/static-language.service";
 export { StorageService } from "./ngx-utils/services/storage.service";
 export { BaseToasterService } from "./ngx-utils/services/base-toaster.service";
+export { CacheService } from "./ngx-utils/services/cache.service";
 export { ComponentLoaderService } from "./ngx-utils/services/component-loader.service";
 export { IUrlDictionary, TranslatedUrlSerializer } from "./ngx-utils/services/translated-url.serializer";
 export { PromiseService } from "./ngx-utils/services/promise.service";