@lenne.tech/ng-base 15.0.0-beta-3 → 16.1.0

package/esm2022/shared/services/breadcrumb.service.mjs

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, filter } from 'rxjs';
+import { NavigationEnd } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+class BreadcrumbService {
+    router;
+    _breadcrumbs = new BehaviorSubject([]);
+    set breadcrumbs(value) {
+        this._breadcrumbs.next(value);
+    }
+    get breadcrumbsObservable() {
+        return this._breadcrumbs.asObservable();
+    }
+    constructor(router) {
+        this.router = router;
+        this.subscribeToRouteChanges();
+    }
+    /**
+     * Subscribe to route changes and add element to breadcrumb
+     */
+    subscribeToRouteChanges() {
+        this.router.events.pipe(filter((event) => event instanceof NavigationEnd)).subscribe((event) => {
+            const root = this.router.routerState.snapshot.root;
+            const breadcrumbs = [];
+            this.addBreadcrumb(root, [], breadcrumbs);
+            this.breadcrumbs = breadcrumbs;
+        });
+    }
+    /**
+     * Add element to breadcrumb
+     *
+     * @param route
+     * @param parentUrl
+     * @param breadcrumbs
+     * @private
+     */
+    addBreadcrumb(route, parentUrl, breadcrumbs) {
+        if (route) {
+            const routeUrl = parentUrl.concat(route.url.map((url) => url.path));
+            if (route.data?.breadcrumb) {
+                const breadcrumb = {
+                    label: this.getLabel(route.data),
+                    url: '/' + routeUrl.join('/'),
+                };
+                breadcrumbs.push(breadcrumb);
+            }
+            this.addBreadcrumb(route.firstChild, routeUrl, breadcrumbs);
+        }
+    }
+    /**
+     * Get label for breadcrumb
+     *
+     * @param data
+     * @private
+     */
+    getLabel(data) {
+        return typeof data.breadcrumb === 'function' ? data.breadcrumb(data) : data.breadcrumb;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BreadcrumbService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BreadcrumbService, providedIn: 'root' });
+}
+export { BreadcrumbService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BreadcrumbService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/shared/services/cms.service.mjs

@@ -2,7 +2,8 @@ import { Injectable } from '@angular/core';
 import { GraphQLRequestType } from '../enums/graphql-request-type.enum';
 import * as i0 from "@angular/core";
 import * as i1 from "./graphql.service";
-export class CmsService {
+class CmsService {
+    graphQLService;
     constructor(graphQLService) {
         this.graphQLService = graphQLService;
     }
@@ -69,13 +70,14 @@ export class CmsService {
     lowerCaseFirstLetter(value) {
         return value.charAt(0).toLowerCase() + value.slice(1);
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CmsService, deps: [{ token: i1.GraphQLService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CmsService, providedIn: 'root' });
 }
-CmsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CmsService, deps: [{ token: i1.GraphQLService }], target: i0.ɵɵFactoryTarget.Injectable });
-CmsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CmsService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CmsService, decorators: [{
+export { CmsService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CmsService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i1.GraphQLService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shared/services/file.service.mjs

@@ -0,0 +1,87 @@
+import { Injectable } from '@angular/core';
+import Compressor from 'compressorjs';
+import { HttpHeaders } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/auth.service";
+import * as i2 from "@angular/common/http";
+class FileService {
+    authService;
+    httpClient;
+    constructor(authService, httpClient) {
+        this.authService = authService;
+        this.httpClient = httpClient;
+    }
+    /**
+     * Compress file with options and return file
+     */
+    compress(file, options) {
+        const config = {
+            quality: 0.6,
+            checkOrientation: false,
+            ...options,
+        };
+        return new Promise((resolve, reject) => {
+            new Compressor(file, {
+                success(result) {
+                    // Check if result is blob for convert to file
+                    if (result instanceof Blob) {
+                        resolve(new File([result], result.name));
+                    }
+                    else {
+                        resolve(result);
+                    }
+                },
+                error(err) {
+                    reject(err.message);
+                },
+                ...config,
+            });
+        });
+    }
+    /**
+     * Upload file to server
+     */
+    async upload(url, path, file, compressOptions) {
+        return new Promise(async (resolve, reject) => {
+            if (compressOptions) {
+                file = await this.compress(file, compressOptions);
+            }
+            const data = new FormData();
+            data.append('file', file);
+            const httpOptions = {
+                headers: new HttpHeaders({
+                    Authorization: 'Bearer ' + this.authService.token,
+                }),
+            };
+            this.httpClient.post(url + path, data, httpOptions).subscribe((result) => {
+                resolve(result);
+            }, (err) => {
+                reject(err);
+            });
+        });
+    }
+    delete(url, path, id) {
+        return new Promise(async (resolve, reject) => {
+            const httpOptions = {
+                headers: new HttpHeaders({
+                    Authorization: 'Bearer ' + this.authService.token,
+                }),
+            };
+            this.httpClient.delete(url + path + id, httpOptions).subscribe((result) => {
+                resolve(result);
+            }, (err) => {
+                reject(err);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FileService, deps: [{ token: i1.AuthService }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FileService, providedIn: 'root' });
+}
+export { FileService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AuthService }, { type: i2.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shared/services/forms.service.mjs

@@ -0,0 +1,62 @@
+import { Inject, Injectable } from '@angular/core';
+import { UntypedFormControl, UntypedFormGroup } from '@angular/forms';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "./scroll.service";
+class FormsService {
+    document;
+    scrollService;
+    constructor(document, scrollService) {
+        this.document = document;
+        this.scrollService = scrollService;
+    }
+    validateAllFormFields(formGroup) {
+        Object.keys(formGroup.controls).forEach((field) => {
+            const control = formGroup.get(field);
+            if (control instanceof UntypedFormControl) {
+                control.markAsTouched({ onlySelf: true });
+            }
+            else if (control instanceof UntypedFormGroup) {
+                this.validateAllFormFields(control);
+            }
+        });
+    }
+    findInvalidControls(formGroup) {
+        return this.getInvalidControl(formGroup);
+    }
+    getInvalidControl(formGroup, invalid, parents = []) {
+        let result = invalid ? [...invalid] : [];
+        let nestedParents = [...[], ...parents];
+        const controls = formGroup.controls;
+        Object.keys(formGroup.controls).forEach((name) => {
+            if (controls[name].invalid) {
+                if (controls[name]?.controls) {
+                    nestedParents.push(name);
+                    result = this.getInvalidControl(controls[name], result, nestedParents);
+                    nestedParents = [];
+                }
+                else {
+                    result.push(nestedParents.length ? nestedParents.join('.') + '.' + name : name);
+                }
+            }
+        });
+        return result;
+    }
+    scrollToInvalidControl(form) {
+        const invalidForm = this.findInvalidControls(form)[0];
+        this.scrollService.scrollTo(invalidForm);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FormsService, deps: [{ token: DOCUMENT }, { token: i1.ScrollService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FormsService, providedIn: 'root' });
+}
+export { FormsService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FormsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.ScrollService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/shared/services/graphql-meta.service.mjs

@@ -0,0 +1,133 @@
+import { gql } from 'apollo-angular';
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { buildClientSchema, getIntrospectionQuery } from 'graphql';
+import { map } from 'rxjs/operators';
+import { GraphQLMeta } from '../classes/graphql-meta.class';
+import { Helper } from '../classes/helper.class';
+import * as i0 from "@angular/core";
+import * as i1 from "apollo-angular";
+/**
+ * GraphQL meta service
+ *
+ * For collecting meta information of the GraphQL API
+ */
+class GraphQLMetaService {
+    apollo;
+    // Caches
+    _frozenSchema;
+    _frozenSchemaObservable;
+    _meta;
+    _metaObservable;
+    _schemaObservable;
+    // Private caches
+    _introspectionQuery;
+    /**
+     * Include services
+     */
+    constructor(apollo) {
+        this.apollo = apollo;
+    }
+    /**
+     * Getter of introspectionQuery
+     */
+    get introspectionQuery() {
+        return JSON.parse(JSON.stringify(this._introspectionQuery));
+    }
+    /**
+     * Get schema for API
+     * See https://www.apollographql.com/blog/three-ways-to-represent-your-graphql-schema-a41f4175100d
+     */
+    getSchema(options = {}) {
+        // Get configurations
+        const config = {
+            cache: true,
+            freeze: true,
+            ...options,
+        };
+        // Use caching
+        if (config.cache) {
+            if (config.freeze && this._frozenSchema) {
+                return of(this._frozenSchema);
+            }
+            if (this._introspectionQuery) {
+                return of(buildClientSchema(this.introspectionQuery));
+            }
+            if (config.freeze && this._frozenSchemaObservable) {
+                return this._frozenSchemaObservable;
+            }
+            else if (!config.freeze && this._schemaObservable) {
+                return this._schemaObservable;
+            }
+        }
+        // Request schema from server
+        const observable = this.apollo
+            .query({
+            query: gql(getIntrospectionQuery({ descriptions: false })),
+        })
+            .pipe(map((schema) => {
+            // Cache introspectionQuery
+            this._introspectionQuery = schema.data;
+            // Convert schema to GraphQLSchema
+            this._frozenSchema = Helper.deepFreeze(buildClientSchema(this.introspectionQuery));
+            // Return GraphQLSchema
+            if (config.freeze) {
+                return this._frozenSchema;
+            }
+            return buildClientSchema(schema.data);
+        }));
+        // Set observables
+        if (config.freeze) {
+            this._frozenSchemaObservable = observable;
+        }
+        else {
+            this._schemaObservable = observable;
+        }
+        // Return result
+        return observable;
+    }
+    /**
+     * Get meta for API
+     * See https://www.apollographql.com/blog/three-ways-to-represent-your-graphql-schema-a41f4175100d
+     */
+    getMeta(options = {}) {
+        // Get configurations
+        const config = {
+            cache: true,
+            log: false,
+            ...options,
+        };
+        // Use caching
+        if (config.cache) {
+            if (this._meta) {
+                return of(this._meta);
+            }
+            else if (this._metaObservable) {
+                return this._metaObservable;
+            }
+        }
+        // Request schema from server
+        const observable = this.getSchema(options).pipe(map((schema) => {
+            // Log
+            if (config.log) {
+                console.log({ schema });
+            }
+            this._meta = new GraphQLMeta(schema);
+            return this._meta;
+        }));
+        // Set observables
+        this._metaObservable = observable;
+        // Return result
+        return observable;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GraphQLMetaService, deps: [{ token: i1.Apollo }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GraphQLMetaService, providedIn: 'root' });
+}
+export { GraphQLMetaService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GraphQLMetaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graphql-meta.service.js","sourceRoot":"","sources":["../../../../../projects/ng-base/shared/services/graphql-meta.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Apollo, gql } from 'apollo-angular';\nimport { Injectable } from '@angular/core';\nimport { Observable, of } from 'rxjs';\nimport { buildClientSchema, getIntrospectionQuery, GraphQLSchema, IntrospectionQuery } from 'graphql';\nimport { map } from 'rxjs/operators';\nimport { GraphQLMeta } from '../classes/graphql-meta.class';\nimport { Helper } from '../classes/helper.class';\n\n/**\n * GraphQL meta service\n *\n * For collecting meta information of the GraphQL API\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class GraphQLMetaService {\n  // Caches\n  protected _frozenSchema: GraphQLSchema;\n  protected _frozenSchemaObservable: Observable<GraphQLSchema>;\n  protected _meta: GraphQLMeta;\n  protected _metaObservable: Observable<GraphQLMeta>;\n  protected _schemaObservable: Observable<GraphQLSchema>;\n\n  // Private caches\n  private _introspectionQuery: IntrospectionQuery;\n\n  /**\n   * Include services\n   */\n  constructor(protected apollo: Apollo) {}\n\n  /**\n   * Getter of introspectionQuery\n   */\n  get introspectionQuery(): IntrospectionQuery {\n    return JSON.parse(JSON.stringify(this._introspectionQuery));\n  }\n\n  /**\n   * Get schema for API\n   * See https://www.apollographql.com/blog/three-ways-to-represent-your-graphql-schema-a41f4175100d\n   */\n  public getSchema(options: { cache?: boolean; freeze?: boolean } = {}): Observable<GraphQLSchema> {\n    // Get configurations\n    const config = {\n      cache: true,\n      freeze: true,\n      ...options,\n    };\n\n    // Use caching\n    if (config.cache) {\n      if (config.freeze && this._frozenSchema) {\n        return of(this._frozenSchema);\n      }\n      if (this._introspectionQuery) {\n        return of(buildClientSchema(this.introspectionQuery));\n      }\n      if (config.freeze && this._frozenSchemaObservable) {\n        return this._frozenSchemaObservable;\n      } else if (!config.freeze && this._schemaObservable) {\n        return this._schemaObservable;\n      }\n    }\n\n    // Request schema from server\n    const observable = this.apollo\n      .query({\n        query: gql(getIntrospectionQuery({ descriptions: false })),\n      })\n      .pipe(\n        map((schema: any) => {\n          // Cache introspectionQuery\n          this._introspectionQuery = schema.data;\n\n          // Convert schema to GraphQLSchema\n          this._frozenSchema = Helper.deepFreeze(buildClientSchema(this.introspectionQuery));\n\n          // Return GraphQLSchema\n          if (config.freeze) {\n            return this._frozenSchema;\n          }\n          return buildClientSchema(schema.data);\n        })\n      );\n\n    // Set observables\n    if (config.freeze) {\n      this._frozenSchemaObservable = observable;\n    } else {\n      this._schemaObservable = observable;\n    }\n\n    // Return result\n    return observable;\n  }\n\n  /**\n   * Get meta for API\n   * See https://www.apollographql.com/blog/three-ways-to-represent-your-graphql-schema-a41f4175100d\n   */\n  public getMeta(options: { cache?: boolean; log?: boolean } = {}): Observable<GraphQLMeta> {\n    // Get configurations\n    const config = {\n      cache: true,\n      log: false,\n      ...options,\n    };\n\n    // Use caching\n    if (config.cache) {\n      if (this._meta) {\n        return of(this._meta);\n      } else if (this._metaObservable) {\n        return this._metaObservable;\n      }\n    }\n\n    // Request schema from server\n    const observable = this.getSchema(options).pipe(\n      map((schema: any) => {\n        // Log\n        if (config.log) {\n          console.log({ schema });\n        }\n\n        this._meta = new GraphQLMeta(schema);\n        return this._meta;\n      })\n    );\n\n    // Set observables\n    this._metaObservable = observable;\n\n    // Return result\n    return observable;\n  }\n}\n"]}

package/esm2022/shared/services/graphql-plus.service.mjs

@@ -0,0 +1,94 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { GraphQLService } from './graphql.service';
+import { GraphQLRequestType } from '../enums/graphql-request-type.enum';
+import { BASE_MODULE_CONFIG } from '../interfaces/base-module-config.interface';
+import * as i0 from "@angular/core";
+import * as i1 from "apollo-angular";
+import * as i2 from "./graphql-meta.service";
+import * as i3 from "./loader.service";
+/**
+ * GraphQL plus service, for extra error handling and loading indication
+ */
+class GraphQLPlusService extends GraphQLService {
+    apollo;
+    graphqlMetaService;
+    loaderService;
+    moduleConfig;
+    /**
+     * Include services
+     */
+    constructor(apollo, graphqlMetaService, loaderService, moduleConfig) {
+        super(apollo, graphqlMetaService, moduleConfig);
+        this.apollo = apollo;
+        this.graphqlMetaService = graphqlMetaService;
+        this.loaderService = loaderService;
+        this.moduleConfig = moduleConfig;
+    }
+    graphQl(graphql, options = {}) {
+        this.handleLoader('start', options);
+        return new Observable((subscriber) => {
+            super.graphQl(graphql, options).subscribe((response) => {
+                if (response && response.errors) {
+                    this.handleError(response.errors, options.excludedErrors);
+                    subscriber.error(response);
+                    this.handleLoader('stop', options);
+                    subscriber.complete();
+                }
+                subscriber.next(response);
+                this.handleLoader('stop', options);
+                if (options.type !== GraphQLRequestType.SUBSCRIPTION) {
+                    subscriber.complete();
+                }
+            }, (error) => {
+                if (!options.ignoreErrors) {
+                    this.handleError(error, options.excludedErrors);
+                }
+                subscriber.error(error);
+                this.handleLoader('stop', options);
+                subscriber.complete();
+            });
+        });
+    }
+    handleLoader(state, options) {
+        if (options.loading) {
+            if (state === 'start') {
+                this.loaderService.start();
+            }
+            else if (state === 'stop') {
+                this.loaderService.stop();
+            }
+        }
+    }
+    handleError(error, excludedErrors = null) {
+        if (excludedErrors) {
+            if (Array.isArray(excludedErrors)) {
+                excludedErrors.forEach((excludedError) => {
+                    if (error.message.includes(excludedError.toLowerCase())) {
+                        return;
+                    }
+                });
+            }
+            else if (error.message.toLowerCase().includes(excludedErrors?.toLowerCase())) {
+                return;
+            }
+        }
+        this.displayError(error);
+    }
+    displayError(error) {
+        console.error(error);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GraphQLPlusService, deps: [{ token: i1.Apollo }, { token: i2.GraphQLMetaService }, { token: i3.LoaderService }, { token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GraphQLPlusService, providedIn: 'root' });
+}
+export { GraphQLPlusService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GraphQLPlusService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }, { type: i2.GraphQLMetaService }, { type: i3.LoaderService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BASE_MODULE_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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