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

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

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+class ToastService {
+    toastsObservables = new BehaviorSubject([]);
+    get toastsAsObservable() {
+        return this.toastsObservables.asObservable();
+    }
+    /**
+     * Show new toast
+     *
+     * @param toast
+     * @param duration
+     */
+    show(toast, duration = 2300) {
+        const value = this.toastsObservables.value;
+        value.push(toast);
+        this.toastsObservables.next(value);
+        if (duration) {
+            setTimeout(() => {
+                const currentToasts = this.toastsObservables.value;
+                const foundIndex = currentToasts.findIndex((e) => e.id === toast.id);
+                if (foundIndex > -1) {
+                    currentToasts.splice(foundIndex, 1);
+                    this.toastsObservables.next(currentToasts);
+                }
+            }, duration);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ToastService, providedIn: 'root' });
+}
+export { ToastService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ToastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3Quc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLWJhc2Uvc2hhcmVkL3NlcnZpY2VzL3RvYXN0LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sTUFBTSxDQUFDOztBQUd2QyxNQUdhLFlBQVk7SUFDZixpQkFBaUIsR0FBRyxJQUFJLGVBQWUsQ0FBVSxFQUFFLENBQUMsQ0FBQztJQUU3RCxJQUFJLGtCQUFrQjtRQUNwQixPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUMvQyxDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSCxJQUFJLENBQUMsS0FBWSxFQUFFLFFBQVEsR0FBRyxJQUFJO1FBQ2hDLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLENBQUM7UUFDM0MsS0FBSyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNsQixJQUFJLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBRW5DLElBQUksUUFBUSxFQUFFO1lBQ1osVUFBVSxDQUFDLEdBQUcsRUFBRTtnQkFDZCxNQUFNLGFBQWEsR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsS0FBSyxDQUFDO2dCQUNuRCxNQUFNLFVBQVUsR0FBRyxhQUFhLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxLQUFLLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQztnQkFFckUsSUFBSSxVQUFVLEdBQUcsQ0FBQyxDQUFDLEVBQUU7b0JBQ25CLGFBQWEsQ0FBQyxNQUFNLENBQUMsVUFBVSxFQUFFLENBQUMsQ0FBQyxDQUFDO29CQUNwQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLGFBQWEsQ0FBQyxDQUFDO2lCQUM1QztZQUNILENBQUMsRUFBRSxRQUFRLENBQUMsQ0FBQztTQUNkO0lBQ0gsQ0FBQzt1R0E3QlUsWUFBWTsyR0FBWixZQUFZLGNBRlgsTUFBTTs7U0FFUCxZQUFZOzJGQUFaLFlBQVk7a0JBSHhCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBUb2FzdCB9IGZyb20gJy4uL2ludGVyZmFjZXMvdG9hc3QuaW50ZXJmYWNlJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIFRvYXN0U2VydmljZSB7XG4gIHByaXZhdGUgdG9hc3RzT2JzZXJ2YWJsZXMgPSBuZXcgQmVoYXZpb3JTdWJqZWN0PFRvYXN0W10+KFtdKTtcblxuICBnZXQgdG9hc3RzQXNPYnNlcnZhYmxlKCkge1xuICAgIHJldHVybiB0aGlzLnRvYXN0c09ic2VydmFibGVzLmFzT2JzZXJ2YWJsZSgpO1xuICB9XG5cbiAgLyoqXG4gICAqIFNob3cgbmV3IHRvYXN0XG4gICAqXG4gICAqIEBwYXJhbSB0b2FzdFxuICAgKiBAcGFyYW0gZHVyYXRpb25cbiAgICovXG4gIHNob3codG9hc3Q6IFRvYXN0LCBkdXJhdGlvbiA9IDIzMDApIHtcbiAgICBjb25zdCB2YWx1ZSA9IHRoaXMudG9hc3RzT2JzZXJ2YWJsZXMudmFsdWU7XG4gICAgdmFsdWUucHVzaCh0b2FzdCk7XG4gICAgdGhpcy50b2FzdHNPYnNlcnZhYmxlcy5uZXh0KHZhbHVlKTtcblxuICAgIGlmIChkdXJhdGlvbikge1xuICAgICAgc2V0VGltZW91dCgoKSA9PiB7XG4gICAgICAgIGNvbnN0IGN1cnJlbnRUb2FzdHMgPSB0aGlzLnRvYXN0c09ic2VydmFibGVzLnZhbHVlO1xuICAgICAgICBjb25zdCBmb3VuZEluZGV4ID0gY3VycmVudFRvYXN0cy5maW5kSW5kZXgoKGUpID0+IGUuaWQgPT09IHRvYXN0LmlkKTtcblxuICAgICAgICBpZiAoZm91bmRJbmRleCA+IC0xKSB7XG4gICAgICAgICAgY3VycmVudFRvYXN0cy5zcGxpY2UoZm91bmRJbmRleCwgMSk7XG4gICAgICAgICAgdGhpcy50b2FzdHNPYnNlcnZhYmxlcy5uZXh0KGN1cnJlbnRUb2FzdHMpO1xuICAgICAgICB9XG4gICAgICB9LCBkdXJhdGlvbik7XG4gICAgfVxuICB9XG59XG4iXX0=

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

@@ -0,0 +1,161 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import { Auth } from '../classes/auth.class';
+import { BasicUser } from '../classes/basic-user.class';
+import { GraphQLRequestType } from '../enums/graphql-request-type.enum';
+import { GraphQLPlusService } from './graphql-plus.service';
+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";
+import * as i4 from "./auth.service";
+class UserService extends GraphQLPlusService {
+    apollo;
+    graphqlMetaService;
+    loaderService;
+    authService;
+    moduleConfig;
+    constructor(apollo, graphqlMetaService, loaderService, authService, moduleConfig) {
+        super(apollo, graphqlMetaService, loaderService, moduleConfig);
+        this.apollo = apollo;
+        this.graphqlMetaService = graphqlMetaService;
+        this.loaderService = loaderService;
+        this.authService = authService;
+        this.moduleConfig = moduleConfig;
+    }
+    /**
+     * Login
+     *
+     * @param input
+     */
+    login(input) {
+        return this.graphQl('signIn', {
+            arguments: { input: { ...input, deviceDescription: navigator?.userAgent } },
+            fields: ['refreshToken', 'token', { user: ['id', 'firstName', 'lastName', 'email', 'roles', 'avatar'] }],
+            loading: true,
+        }).pipe(map((response) => {
+            this.authService.token = response.token;
+            this.authService.refreshToken = response.refreshToken;
+            this.authService.currentUser = response.user;
+            return Auth.map({
+                token: response.token,
+                refreshToken: response.refreshToken,
+                user: BasicUser.map(response.user),
+            });
+        }));
+    }
+    /**
+     * Register
+     *
+     * @param input
+     */
+    register(input) {
+        return this.graphQl('signUp', {
+            arguments: { input: { ...input, deviceDescription: navigator?.userAgent } },
+            fields: ['refreshToken', 'token', { user: ['id', 'firstName', 'lastName', 'email', 'roles', 'avatar'] }],
+            loading: true,
+        }).pipe(map((response) => {
+            this.authService.token = response.token;
+            this.authService.refreshToken = response.refreshToken;
+            this.authService.currentUser = response.user;
+            return Auth.map({
+                token: response.token,
+                refreshToken: response.refreshToken,
+                user: BasicUser.map(response.user),
+            });
+        }));
+    }
+    /**
+     * This function will make a GraphQL query to the server, and return the result
+     *
+     * @param id - The id of the user you want to get
+     * @returns A GraphQLRequest object.
+     */
+    get(id) {
+        return this.graphQl('getUser', {
+            arguments: { id },
+            fields: ['id', 'firstName', 'lastName', 'email', 'roles', 'avatar'],
+            type: GraphQLRequestType.QUERY,
+            loading: true,
+        });
+    }
+    /**
+     * Request password reset mail
+     *
+     * @param email
+     */
+    requestPasswordResetMail(email) {
+        return this.graphQl('requestPasswordResetMail', {
+            arguments: { email },
+            fields: [],
+            type: GraphQLRequestType.QUERY,
+            loading: true,
+        });
+    }
+    /**
+     * Change password of current user
+     *
+     * @param id
+     * @param password
+     */
+    changePassword(id, password) {
+        return this.graphQl('updateUser', {
+            arguments: { id, input: { password } },
+            fields: ['id'],
+            type: GraphQLRequestType.MUTATION,
+            loading: true,
+        });
+    }
+    /**
+     * Set new password by token
+     *
+     * @param token
+     * @param password
+     */
+    resetPassword(token, password) {
+        return this.graphQl('resetPassword', {
+            arguments: { token, password },
+            type: GraphQLRequestType.MUTATION,
+            loading: true,
+        });
+    }
+    /**
+     * Delete user by id
+     *
+     * @param id
+     */
+    delete(id) {
+        return this.graphQl('deleteUser', {
+            arguments: { id },
+            fields: ['id'],
+            type: GraphQLRequestType.MUTATION,
+            loading: true,
+        });
+    }
+    /**
+     * Verify user by token
+     *
+     * @param token
+     */
+    verifyUser(token) {
+        return this.graphQl('verifyUser', {
+            arguments: { token },
+            type: GraphQLRequestType.MUTATION,
+            loading: true,
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: UserService, deps: [{ token: i1.Apollo }, { token: i2.GraphQLMetaService }, { token: i3.LoaderService }, { token: i4.AuthService }, { token: BASE_MODULE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: UserService, providedIn: 'root' });
+}
+export { UserService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: UserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }, { type: i2.GraphQLMetaService }, { type: i3.LoaderService }, { type: i4.AuthService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BASE_MODULE_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.service.js","sourceRoot":"","sources":["../../../../../projects/ng-base/shared/services/user.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Apollo } from 'apollo-angular';\nimport { map } from 'rxjs';\nimport { Auth } from '../classes/auth.class';\nimport { BasicUser } from '../classes/basic-user.class';\nimport { GraphQLRequestType } from '../enums/graphql-request-type.enum';\nimport { AuthService } from './auth.service';\nimport { GraphQLMetaService } from './graphql-meta.service';\nimport { GraphQLPlusService } from './graphql-plus.service';\nimport { LoaderService } from './loader.service';\nimport { BASE_MODULE_CONFIG, BaseModuleConfig } from '../interfaces/base-module-config.interface';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class UserService extends GraphQLPlusService {\n  constructor(\n    protected apollo: Apollo,\n    protected graphqlMetaService: GraphQLMetaService,\n    protected loaderService: LoaderService,\n    protected authService: AuthService,\n    @Inject(BASE_MODULE_CONFIG) protected moduleConfig: BaseModuleConfig\n  ) {\n    super(apollo, graphqlMetaService, loaderService, moduleConfig);\n  }\n\n  /**\n   * Login\n   *\n   * @param input\n   */\n  login(input: { email: string; password: string }) {\n    return this.graphQl('signIn', {\n      arguments: { input: { ...input, deviceDescription: navigator?.userAgent } },\n      fields: ['refreshToken', 'token', { user: ['id', 'firstName', 'lastName', 'email', 'roles', 'avatar'] }],\n      loading: true,\n    }).pipe(\n      map((response: Auth) => {\n        this.authService.token = response.token;\n        this.authService.refreshToken = response.refreshToken;\n        this.authService.currentUser = response.user;\n\n        return Auth.map({\n          token: response.token,\n          refreshToken: response.refreshToken,\n          user: BasicUser.map(response.user),\n        });\n      })\n    );\n  }\n\n  /**\n   * Register\n   *\n   * @param input\n   */\n  register(input: { firstName: string; lastName: string; email: string; password: string }) {\n    return this.graphQl('signUp', {\n      arguments: { input: { ...input, deviceDescription: navigator?.userAgent } },\n      fields: ['refreshToken', 'token', { user: ['id', 'firstName', 'lastName', 'email', 'roles', 'avatar'] }],\n      loading: true,\n    }).pipe(\n      map((response: Auth) => {\n        this.authService.token = response.token;\n        this.authService.refreshToken = response.refreshToken;\n        this.authService.currentUser = response.user;\n\n        return Auth.map({\n          token: response.token,\n          refreshToken: response.refreshToken,\n          user: BasicUser.map(response.user),\n        });\n      })\n    );\n  }\n\n  /**\n   * This function will make a GraphQL query to the server, and return the result\n   *\n   * @param id - The id of the user you want to get\n   * @returns A GraphQLRequest object.\n   */\n  get(id: string) {\n    return this.graphQl('getUser', {\n      arguments: { id },\n      fields: ['id', 'firstName', 'lastName', 'email', 'roles', 'avatar'],\n      type: GraphQLRequestType.QUERY,\n      loading: true,\n    });\n  }\n\n  /**\n   * Request password reset mail\n   *\n   * @param email\n   */\n  requestPasswordResetMail(email: string) {\n    return this.graphQl('requestPasswordResetMail', {\n      arguments: { email },\n      fields: [],\n      type: GraphQLRequestType.QUERY,\n      loading: true,\n    });\n  }\n\n  /**\n   * Change password of current user\n   *\n   * @param id\n   * @param password\n   */\n  changePassword(id: string, password: string) {\n    return this.graphQl('updateUser', {\n      arguments: { id, input: { password } },\n      fields: ['id'],\n      type: GraphQLRequestType.MUTATION,\n      loading: true,\n    });\n  }\n\n  /**\n   * Set new password by token\n   *\n   * @param token\n   * @param password\n   */\n  resetPassword(token: string, password: string) {\n    return this.graphQl('resetPassword', {\n      arguments: { token, password },\n      type: GraphQLRequestType.MUTATION,\n      loading: true,\n    });\n  }\n\n  /**\n   * Delete user by id\n   *\n   * @param id\n   */\n  delete(id: string) {\n    return this.graphQl('deleteUser', {\n      arguments: { id },\n      fields: ['id'],\n      type: GraphQLRequestType.MUTATION,\n      loading: true,\n    });\n  }\n\n  /**\n   * Verify user by token\n   *\n   * @param token\n   */\n  verifyUser(token: string) {\n    return this.graphQl('verifyUser', {\n      arguments: { token },\n      type: GraphQLRequestType.MUTATION,\n      loading: true,\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+class WsService {
+    client;
+    reconnect() {
+        this.client?.restart();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WsService, providedIn: 'root' });
+}
+export { WsService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3Muc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLWJhc2Uvc2hhcmVkL3NlcnZpY2VzL3dzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHM0MsTUFHYSxTQUFTO0lBQ3BCLE1BQU0sQ0FBb0I7SUFFMUIsU0FBUztRQUNQLElBQUksQ0FBQyxNQUFNLEVBQUUsT0FBTyxFQUFFLENBQUM7SUFDekIsQ0FBQzt1R0FMVSxTQUFTOzJHQUFULFNBQVMsY0FGUixNQUFNOztTQUVQLFNBQVM7MkZBQVQsU0FBUztrQkFIckIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBSZXN0YXJ0YWJsZUNsaWVudCB9IGZyb20gJy4uL2Z1bmN0aW9ucy93cy1jbGllbnQuZnVuY3Rpb24nO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgV3NTZXJ2aWNlIHtcbiAgY2xpZW50OiBSZXN0YXJ0YWJsZUNsaWVudDtcblxuICByZWNvbm5lY3QoKSB7XG4gICAgdGhpcy5jbGllbnQ/LnJlc3RhcnQoKTtcbiAgfVxufVxuIl19

package/esm2022/src/base.module.mjs

@@ -0,0 +1,98 @@
+import { APOLLO_OPTIONS, ApolloModule } from 'apollo-angular';
+import { HttpLink } from 'apollo-angular/http';
+import { NgModule } from '@angular/core';
+import { apolloOptionsFactory } from './factories/apollo-options.factory';
+import { LazyLoadDirective } from './directives/lazy-load.directive';
+import { MatchHeightDirective } from './directives/match-height.directive';
+import { ResizableDirective } from './directives/resizable.directive';
+import { SafeHtmlPipe } from './pipes/safe-html.pipe';
+import { DateAgoPipe } from './pipes/date-ago.pipe';
+import { AuthService, BASE_MODULE_CONFIG, WsService } from '@lenne.tech/ng-base/shared';
+import { HttpClientModule } from '@angular/common/http';
+import * as i0 from "@angular/core";
+// Imported and exported elements
+const elements = [
+    // Directives
+    LazyLoadDirective,
+    MatchHeightDirective,
+    ResizableDirective,
+    // Pipes
+    SafeHtmlPipe,
+    DateAgoPipe,
+];
+/**
+ * Base module
+ */
+class BaseModule {
+    /**
+     * Set configuration of base module in root module of the app
+     */
+    static forRoot(baseModuleConfig = {}, AppAuthService) {
+        // Default config
+        const config = {
+            apiUrl: '',
+            authGuardRedirectUrl: '/auth',
+            logging: false,
+            version: null,
+            prefix: null,
+            scrollDetectionOffset: 200,
+            scrollOffset: 100,
+            storageType: 'local',
+            securePasswordTransfer: true,
+            ...baseModuleConfig,
+        };
+        if (config.logging) {
+            console.log('Config:', config);
+        }
+        // Prepare providers
+        const providers = [
+            {
+                provide: BASE_MODULE_CONFIG,
+                useValue: config,
+            },
+        ];
+        // Add apollo features if API URL is set
+        if (baseModuleConfig.apiUrl) {
+            providers.push({
+                provide: APOLLO_OPTIONS,
+                useFactory: apolloOptionsFactory,
+                deps: [BASE_MODULE_CONFIG, HttpLink, AppAuthService ? AppAuthService : AuthService, WsService],
+            });
+        }
+        else if (config.logging) {
+            console.log('apiUrl is missing, ApolloLink is not initialized');
+        }
+        // Return root module
+        return {
+            ngModule: BaseModule,
+            providers,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BaseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: BaseModule, declarations: [
+            // Directives
+            LazyLoadDirective,
+            MatchHeightDirective,
+            ResizableDirective,
+            // Pipes
+            SafeHtmlPipe,
+            DateAgoPipe], imports: [ApolloModule, HttpClientModule], exports: [
+            // Directives
+            LazyLoadDirective,
+            MatchHeightDirective,
+            ResizableDirective,
+            // Pipes
+            SafeHtmlPipe,
+            DateAgoPipe, ApolloModule, HttpClientModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BaseModule, imports: [ApolloModule, HttpClientModule, ApolloModule, HttpClientModule] });
+}
+export { BaseModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BaseModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ApolloModule, HttpClientModule],
+                    declarations: elements,
+                    exports: [...elements, ApolloModule, HttpClientModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/directives/lazy-load.directive.mjs

@@ -0,0 +1,48 @@
+import { Directive, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive for lazy loading images
+ */
+class LazyLoadDirective {
+    el;
+    srcAttr = null;
+    src;
+    constructor(el) {
+        this.el = el;
+    }
+    ngAfterViewInit() {
+        this.canLazyLoad() ? this.lazyLoadImage() : this.loadImage();
+    }
+    canLazyLoad() {
+        return window && 'IntersectionObserver' in window;
+    }
+    lazyLoadImage() {
+        const obs = new IntersectionObserver((entries) => {
+            entries.forEach(({ isIntersecting }) => {
+                if (isIntersecting) {
+                    this.loadImage();
+                    obs.unobserve(this.el.nativeElement);
+                }
+            });
+        });
+        obs.observe(this.el.nativeElement);
+    }
+    loadImage() {
+        this.srcAttr = this.src;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LazyLoadDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: LazyLoadDirective, selector: "img[ltLazyLoad]", inputs: { src: "src" }, host: { properties: { "attr.src": "this.srcAttr" } }, ngImport: i0 });
+}
+export { LazyLoadDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LazyLoadDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'img[ltLazyLoad]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { srcAttr: [{
+                type: HostBinding,
+                args: ['attr.src']
+            }], src: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/directives/match-height.directive.mjs

@@ -0,0 +1,92 @@
+import { Directive, HostListener, Inject, Input, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@lenne.tech/ng-base/shared";
+/**
+ * Set same height (maximum) to different elements
+ */
+class MatchHeightDirective {
+    el;
+    imageService;
+    // class name to match height
+    ltMatchHeight;
+    // Replace lazy loading images with immediate loading images
+    loadImages = true;
+    // Wether current platform is a browser
+    isBrowser;
+    observer;
+    constructor(el, imageService, platformId) {
+        this.el = el;
+        this.imageService = imageService;
+        this.isBrowser = isPlatformBrowser(platformId);
+    }
+    onResize() {
+        this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
+    }
+    ngAfterViewInit() {
+        this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
+        this.observer = new MutationObserver(() => {
+            this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
+        });
+        //Observes if one or more elements get added to or removed from the childlist and applies matching heights
+        this.observer.observe(this.el.nativeElement, { childList: true });
+    }
+    async matchHeight(parent, target) {
+        if (!parent) {
+            return;
+        }
+        let classNames;
+        if (!Array.isArray(target)) {
+            classNames = [target];
+        }
+        else {
+            classNames = target;
+        }
+        for (const className of classNames) {
+            // find all child structureElements with the selected class name
+            const children = parent.getElementsByClassName(className);
+            if (!children || children.length < 2) {
+                continue;
+            }
+            // Load images of children
+            if (this.loadImages) {
+                await this.imageService.preLoadImages({ elements: children });
+            }
+            // reset all children height
+            Array.from(children).forEach((element) => {
+                element.style.height = 'initial';
+            });
+            // get all the child structureElements heights
+            const itemHeights = Array.from(children).map((element) => {
+                if (element.getBoundingClientRect) {
+                    return element.getBoundingClientRect().height;
+                }
+                return 0;
+            });
+            // find out the tallest one
+            const maxHeight = itemHeights.reduce((prev, curr) => (curr > prev ? curr : prev), 0);
+            // update the child structureElements height to the tallest one
+            Array.from(children).forEach((element) => (element.style.height = `${maxHeight}px`));
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MatchHeightDirective, deps: [{ token: i0.ElementRef }, { token: i1.ImageService }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: MatchHeightDirective, selector: "[ltMatchHeight]", inputs: { ltMatchHeight: "ltMatchHeight", loadImages: "loadImages" }, host: { listeners: { "window:resize": "onResize()" } }, ngImport: i0 });
+}
+export { MatchHeightDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MatchHeightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ltMatchHeight]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.ImageService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; }, propDecorators: { ltMatchHeight: [{
+                type: Input
+            }], loadImages: [{
+                type: Input
+            }], onResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/directives/resizable.directive.mjs

@@ -0,0 +1,92 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Reszise detection
+ * (inpsired by: https://stackblitz.com/edit/angular-resizable)
+ */
+class ResizableDirective {
+    el;
+    resizableGrabWidth = 8;
+    resizableMinWidth = 10;
+    dragging = false;
+    constructor(el) {
+        this.el = el;
+    }
+    ngOnInit() {
+        this.addListenerToDocument();
+        this.addListenerToElement();
+    }
+    mouseMoveG(evt) {
+        if (!this.dragging) {
+            return;
+        }
+        this.newWidth(evt.clientX - this.el.nativeElement.offsetLeft);
+        evt.stopPropagation();
+    }
+    newWidth(wid) {
+        const result = Math.max(this.resizableMinWidth, wid);
+        this.el.nativeElement.style.width = result + 'px';
+    }
+    mouseDown(evt) {
+        if (this.inDragRegion(evt)) {
+            this.dragging = true;
+            this.preventGlobalMouseEvents();
+            evt.stopPropagation();
+        }
+    }
+    restoreGlobalMouseEvents() {
+        document.body.style['pointer-events'] = 'auto';
+    }
+    mouseUpG(evt) {
+        if (!this.dragging) {
+            return;
+        }
+        this.restoreGlobalMouseEvents();
+        this.dragging = false;
+        evt.stopPropagation();
+    }
+    mouseMove(evt) {
+        if (this.inDragRegion(evt) || this.dragging) {
+            this.el.nativeElement.style.cursor = 'col-resize';
+        }
+        else {
+            this.el.nativeElement.style.cursor = 'default';
+        }
+    }
+    preventGlobalMouseEvents() {
+        document.body.style['pointer-events'] = 'none';
+    }
+    inDragRegion(evt) {
+        return this.el.nativeElement.clientWidth - evt.clientX + this.el.nativeElement.offsetLeft < this.resizableGrabWidth;
+    }
+    addListenerToDocument() {
+        document.addEventListener('mousemove', (e) => {
+            this.mouseMoveG(e);
+        }, true);
+        document.addEventListener('mouseup', (e) => {
+            this.mouseUpG(e);
+        }, true);
+    }
+    addListenerToElement() {
+        this.el.nativeElement.addEventListener('mousedown', (e) => {
+            this.mouseDown(e);
+        }, true);
+        this.el.nativeElement.addEventListener('mousemove', (e) => {
+            this.mouseMove(e);
+        }, true);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizableDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: ResizableDirective, selector: "[ltResizable]", inputs: { resizableGrabWidth: "resizableGrabWidth", resizableMinWidth: "resizableMinWidth" }, ngImport: i0 });
+}
+export { ResizableDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ResizableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ltResizable]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { resizableGrabWidth: [{
+                type: Input
+            }], resizableMinWidth: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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