@sumaris-net/ngx-components 18.14.15 → 18.14.17

package/esm2022/src/app/social/feed/feed.directive.mjs

@@ -5,8 +5,8 @@ import { UrlUtils } from '../../shared/file/url.utils';
 import { LocationStrategy } from '@angular/common';
 import { isNotNilOrBlank } from '../../shared/functions';
 import { NavController } from '@ionic/angular';
-import { DiscourseUtils } from './discourse/discourse.utils';
 import { PlatformService } from '../../core/services/platform.service';
+import { JsonFeedUtils } from './feed.model';
 import * as i0 from "@angular/core";
 export class FeedDirective {
     element;
@@ -20,7 +20,7 @@ export class FeedDirective {
     _baseUrl;
     set feedUrl(value) {
         this._feedUrl = value;
-        this._baseUrl = value && DiscourseUtils.removeJsonExtension(value);
+        this._baseUrl = value && JsonFeedUtils.removeJsonExtension(value);
     }
     get feedUrl() {
         return this._feedUrl;
@@ -146,6 +146,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 }]
         }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { feedUrl: [{
                 type: Input,
-                args: ['feed']
+                args: [{ alias: 'feed', required: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feed.directive.js","sourceRoot":"","sources":["../../../../../../src/app/social/feed/feed.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, ElementRef, inject, Input, OnDestroy } from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { ActivatedRoute, Router, UrlTree } from '@angular/router';\nimport { UrlUtils } from '../../shared/file/url.utils';\nimport { LocationStrategy } from '@angular/common';\nimport { isNotNilOrBlank } from '../../shared/functions';\nimport { NavController } from '@ionic/angular';\nimport { DiscourseUtils } from './discourse/discourse.utils';\nimport { PlatformService } from '../../core/services/platform.service';\n\n@Directive({\n  selector: 'feed,[feed]',\n})\nexport class FeedDirective implements AfterViewInit, OnDestroy {\n  private _subscription = new Subscription();\n  private platform = inject(PlatformService);\n  private locationStrategy = inject(LocationStrategy);\n  private navController = inject(NavController);\n  private router = inject(Router);\n  private route = inject(ActivatedRoute);\n\n  private _feedUrl: string;\n  private _baseUrl: string;\n\n  @Input('feed') set feedUrl(value: string) {\n    this._feedUrl = value;\n    this._baseUrl = value && DiscourseUtils.removeJsonExtension(value);\n  }\n\n  get feedUrl(): string {\n    return this._feedUrl;\n  }\n\n  constructor(private element: ElementRef<HTMLElement>) {\n    // DEBUG\n    //console.debug('[feed-directive] Creating feed directive');\n  }\n\n  public ngAfterViewInit() {\n    console.debug('[feed-directive] Processing anchors');\n    // Listening click events\n    this._subscription.add(this.listenClickEvents(this.element.nativeElement));\n  }\n\n  ngOnDestroy() {\n    this._subscription.unsubscribe();\n  }\n\n  protected listenClickEvents(nativeElement: HTMLElement): Subscription {\n    console.debug('[feed-directive] Start listening click events...');\n    const subscription = new Subscription();\n    const listener = (event: Event) => this.click(event, nativeElement);\n    const links = nativeElement.querySelectorAll('a');\n    links.forEach((link) => {\n      // DEBUG\n      //console.debug('[feed-directive] Adding click listener to', link);\n      link.addEventListener('click', listener);\n      subscription.add(() => link.removeEventListener('click', listener));\n    });\n\n    // DEBUG\n    subscription.add(() => console.debug('[feed-directive] Stop listening click events'));\n\n    return subscription;\n  }\n\n  protected async click(event: Event, containerElement: HTMLElement): Promise<boolean> {\n    console.debug('[feed-directive] Processing click event...', event);\n\n    if (!(event.target instanceof HTMLAnchorElement) && !(event.target?.['tagName'] === 'A')) {\n      console.warn('[feed-directive] Invalid click event target. Should an anchor <a>', event.target);\n      return;\n    }\n\n    const element = event.target as HTMLAnchorElement;\n\n    let href = element.getAttribute('href');\n    const fragment = UrlUtils.getFragment(href);\n\n    // Fragment\n    if (href?.startsWith('#') && isNotNilOrBlank(fragment)) {\n      event.preventDefault();\n      this.scrollToAnchor(containerElement, fragment);\n      return true;\n    }\n\n    const routerLink = element.getAttribute('routerLink');\n    if (isNotNilOrBlank(routerLink)) {\n      event.preventDefault();\n      return this.navController.navigateForward(routerLink);\n    }\n\n    // Resolve relative URL, if baseUrl has been set\n    if (this._baseUrl && UrlUtils.isRelativeUrl(href)) {\n      // Resolve URL, then open using the platform\n      href = UrlUtils.resolveRelativeUrl(this._baseUrl, href);\n    }\n\n    // Resolve internal URL as an app route\n    if (UrlUtils.isInternalUrl(href)) {\n      const routePath = this.normalizeUrl(href.startsWith('/') ? href : `/${href}`);\n      const urlTree = this.getUrlTree(routePath);\n      event.preventDefault();\n      this.router.navigated = false;\n      // Opening route\n      return this.navController.navigateForward(urlTree);\n    }\n\n    // External URL: open using the platform\n    event.preventDefault();\n    await this.platform.open(href);\n    return true;\n  }\n\n  scrollToAnchor(containerElement: HTMLElement, anchorId: string) {\n    if (!containerElement || !anchorId) {\n      console.warn(\"Missing 'containerElement' or 'fragment' argument.\");\n      return;\n    }\n\n    console.debug('[feed-directive-anchor] Scrolling to anchor #' + anchorId);\n\n    // Find the target element with the specified fragment ID\n    const targetElement = containerElement.querySelector(`#${anchorId}`);\n\n    if (targetElement) {\n      // Scroll smoothly to the target element\n      // eslint-disable-next-line @rx-angular/prefer-no-layout-sensitive-apis\n      targetElement.scrollIntoView({\n        behavior: 'smooth', // Smooth scrolling behavior\n        block: 'start', // Align the target element to the top of the container\n      });\n    } else {\n      console.warn(`No element found with the ID \"${anchorId}\" inside the container.`);\n    }\n  }\n\n  /**\n   * Transform a relative URL to its absolute representation according to current router state.\n   * @param url Relative URL path.\n   * @return Absolute URL based on the current route.\n   */\n  normalizeUrl(url: string): string {\n    if (UrlUtils.isExternalUrl(url)) {\n      return url;\n    }\n    if (this._baseUrl && UrlUtils.isRelativeUrl(url)) {\n      return UrlUtils.resolveRelativeUrl(this._baseUrl, url);\n    }\n\n    const urlTree = this.getUrlTree(url);\n    const serializedUrl = this.router.serializeUrl(urlTree);\n    return this.locationStrategy.prepareExternalUrl(serializedUrl);\n  }\n\n  getUrlTree(url: string): UrlTree {\n    url = UrlUtils.normalizeUrl(url);\n    const urlPath = UrlUtils.stripFragmentAndQuery(url) || UrlUtils.stripFragmentAndQuery(this.router.url);\n    const parsedUrl = this.router.parseUrl(url);\n    const fragment = parsedUrl.fragment;\n    const queryParams = parsedUrl.queryParams;\n    return this.router.createUrlTree([urlPath], { relativeTo: this.route, fragment, queryParams });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feed.directive.js","sourceRoot":"","sources":["../../../../../../src/app/social/feed/feed.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Directive, ElementRef, inject, Input, OnDestroy } from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { ActivatedRoute, Router, UrlTree } from '@angular/router';\nimport { UrlUtils } from '../../shared/file/url.utils';\nimport { LocationStrategy } from '@angular/common';\nimport { isNotNilOrBlank } from '../../shared/functions';\nimport { NavController } from '@ionic/angular';\nimport { PlatformService } from '../../core/services/platform.service';\nimport { JsonFeedUtils } from './feed.model';\n\n@Directive({\n  selector: 'feed,[feed]',\n})\nexport class FeedDirective implements AfterViewInit, OnDestroy {\n  private _subscription = new Subscription();\n  private platform = inject(PlatformService);\n  private locationStrategy = inject(LocationStrategy);\n  private navController = inject(NavController);\n  private router = inject(Router);\n  private route = inject(ActivatedRoute);\n\n  private _feedUrl: string;\n  private _baseUrl: string;\n\n  @Input({ alias: 'feed', required: true }) set feedUrl(value: string) {\n    this._feedUrl = value;\n    this._baseUrl = value && JsonFeedUtils.removeJsonExtension(value);\n  }\n\n  get feedUrl(): string {\n    return this._feedUrl;\n  }\n\n  constructor(private element: ElementRef<HTMLElement>) {\n    // DEBUG\n    //console.debug('[feed-directive] Creating feed directive');\n  }\n\n  public ngAfterViewInit() {\n    console.debug('[feed-directive] Processing anchors');\n    // Listening click events\n    this._subscription.add(this.listenClickEvents(this.element.nativeElement));\n  }\n\n  ngOnDestroy() {\n    this._subscription.unsubscribe();\n  }\n\n  protected listenClickEvents(nativeElement: HTMLElement): Subscription {\n    console.debug('[feed-directive] Start listening click events...');\n    const subscription = new Subscription();\n    const listener = (event: Event) => this.click(event, nativeElement);\n    const links = nativeElement.querySelectorAll('a');\n    links.forEach((link) => {\n      // DEBUG\n      //console.debug('[feed-directive] Adding click listener to', link);\n      link.addEventListener('click', listener);\n      subscription.add(() => link.removeEventListener('click', listener));\n    });\n\n    // DEBUG\n    subscription.add(() => console.debug('[feed-directive] Stop listening click events'));\n\n    return subscription;\n  }\n\n  protected async click(event: Event, containerElement: HTMLElement): Promise<boolean> {\n    console.debug('[feed-directive] Processing click event...', event);\n\n    if (!(event.target instanceof HTMLAnchorElement) && !(event.target?.['tagName'] === 'A')) {\n      console.warn('[feed-directive] Invalid click event target. Should an anchor <a>', event.target);\n      return;\n    }\n\n    const element = event.target as HTMLAnchorElement;\n\n    let href = element.getAttribute('href');\n    const fragment = UrlUtils.getFragment(href);\n\n    // Fragment\n    if (href?.startsWith('#') && isNotNilOrBlank(fragment)) {\n      event.preventDefault();\n      this.scrollToAnchor(containerElement, fragment);\n      return true;\n    }\n\n    const routerLink = element.getAttribute('routerLink');\n    if (isNotNilOrBlank(routerLink)) {\n      event.preventDefault();\n      return this.navController.navigateForward(routerLink);\n    }\n\n    // Resolve relative URL, if baseUrl has been set\n    if (this._baseUrl && UrlUtils.isRelativeUrl(href)) {\n      // Resolve URL, then open using the platform\n      href = UrlUtils.resolveRelativeUrl(this._baseUrl, href);\n    }\n\n    // Resolve internal URL as an app route\n    if (UrlUtils.isInternalUrl(href)) {\n      const routePath = this.normalizeUrl(href.startsWith('/') ? href : `/${href}`);\n      const urlTree = this.getUrlTree(routePath);\n      event.preventDefault();\n      this.router.navigated = false;\n      // Opening route\n      return this.navController.navigateForward(urlTree);\n    }\n\n    // External URL: open using the platform\n    event.preventDefault();\n    await this.platform.open(href);\n    return true;\n  }\n\n  scrollToAnchor(containerElement: HTMLElement, anchorId: string) {\n    if (!containerElement || !anchorId) {\n      console.warn(\"Missing 'containerElement' or 'fragment' argument.\");\n      return;\n    }\n\n    console.debug('[feed-directive-anchor] Scrolling to anchor #' + anchorId);\n\n    // Find the target element with the specified fragment ID\n    const targetElement = containerElement.querySelector(`#${anchorId}`);\n\n    if (targetElement) {\n      // Scroll smoothly to the target element\n      // eslint-disable-next-line @rx-angular/prefer-no-layout-sensitive-apis\n      targetElement.scrollIntoView({\n        behavior: 'smooth', // Smooth scrolling behavior\n        block: 'start', // Align the target element to the top of the container\n      });\n    } else {\n      console.warn(`No element found with the ID \"${anchorId}\" inside the container.`);\n    }\n  }\n\n  /**\n   * Transform a relative URL to its absolute representation according to current router state.\n   * @param url Relative URL path.\n   * @return Absolute URL based on the current route.\n   */\n  normalizeUrl(url: string): string {\n    if (UrlUtils.isExternalUrl(url)) {\n      return url;\n    }\n    if (this._baseUrl && UrlUtils.isRelativeUrl(url)) {\n      return UrlUtils.resolveRelativeUrl(this._baseUrl, url);\n    }\n\n    const urlTree = this.getUrlTree(url);\n    const serializedUrl = this.router.serializeUrl(urlTree);\n    return this.locationStrategy.prepareExternalUrl(serializedUrl);\n  }\n\n  getUrlTree(url: string): UrlTree {\n    url = UrlUtils.normalizeUrl(url);\n    const urlPath = UrlUtils.stripFragmentAndQuery(url) || UrlUtils.stripFragmentAndQuery(this.router.url);\n    const parsedUrl = this.router.parseUrl(url);\n    const fragment = parsedUrl.fragment;\n    const queryParams = parsedUrl.queryParams;\n    return this.router.createUrlTree([urlPath], { relativeTo: this.route, fragment, queryParams });\n  }\n}\n"]}

package/esm2022/src/app/social/feed/feed.service.mjs

@@ -1,3 +1,159 @@
-import { InjectionToken } from '@angular/core';
+import { from, switchMap } from 'rxjs';
+import { JsonFeedUtils } from './feed.model';
+import { Inject, inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { firstArrayValue, isEmptyArray, isNotEmptyArray, isNotNilOrBlank } from '../../shared/functions';
+import { filter, map, mergeMap } from 'rxjs/operators';
+import { StartableService } from '../../shared/services/startable-service.class';
+import { NetworkService } from '../../core/services/network.service';
+import { RxState } from '@rx-angular/state';
+import { ENVIRONMENT } from '../../../environments/environment.class';
+import { UrlUtils } from '../../shared/file/url.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/services/local-settings.service";
+import * as i2 from "../../../environments/environment.class";
 export const APP_FEED_SERVICE = new InjectionToken('FeeService');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVlZC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9zb2NpYWwvZmVlZC9mZWVkLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUvQyxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLGNBQWMsQ0FBb0IsWUFBWSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBMb2FkUmVzdWx0IH0gZnJvbSAnLi4vLi4vc2hhcmVkL3NlcnZpY2VzL2VudGl0eS1zZXJ2aWNlLmNsYXNzJztcbmltcG9ydCB7IEpzb25GZWVkIH0gZnJvbSAnLi9mZWVkLm1vZGVsJztcbmltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBBUFBfRkVFRF9TRVJWSUNFID0gbmV3IEluamVjdGlvblRva2VuPElGZWVkU2VydmljZTxhbnk+PignRmVlU2VydmljZScpO1xuXG5leHBvcnQgaW50ZXJmYWNlIElGZWVkU2VydmljZTxUIGV4dGVuZHMgSnNvbkZlZWQgPSBKc29uRmVlZD4ge1xuICB3YXRjaEFsbChvcHRzPzogeyB1cmxzPzogc3RyaW5nW107IG1heEFnZUluTW9udGhzPzogbnVtYmVyOyBtYXhDb250ZW50TGVuZ3RoPzogbnVtYmVyIH0pOiBPYnNlcnZhYmxlPExvYWRSZXN1bHQ8VD4+O1xuXG4gIGdldEhvbWVVcmwoZmVlZD86IFQpOiBzdHJpbmc7XG5cbiAgZ2V0VGFnVXJsKGZlZWQ6IFQsIHRhZzogc3RyaW5nKTogc3RyaW5nO1xufVxuIl19
+export class FeedService extends StartableService {
+    settings;
+    environment;
+    _logPrefix = '[feed-service] ';
+    _state = new RxState();
+    network = inject(NetworkService);
+    locale$ = this._state.select('locale');
+    feedUrls$ = this._state.select('feedUrls');
+    get feedUrls() {
+        return this._state.get('feedUrls');
+    }
+    set feedUrls(urls) {
+        this._state.set('feedUrls', () => urls);
+    }
+    constructor(settings, environment) {
+        super(settings);
+        this.settings = settings;
+        this.environment = environment;
+        this._state.connect('locale', this.settings.locale$);
+        this._state.connect('feedUrls', this.locale$.pipe(filter(isNotNilOrBlank), map((locale) => (locale && environment.feed?.jsonFeed?.[locale]) ?? [])));
+        // DEBUG
+        this._debug = !environment.production;
+        if (this._debug)
+            console.debug(`${this._logPrefix}created`);
+    }
+    async ngOnStart() {
+        await this.settings.ready();
+        return {
+            locale: this.settings.locale,
+        };
+    }
+    watchAll(opts) {
+        if (!this.started) {
+            return from(this.start()).pipe(switchMap(() => this.watchAll(opts)));
+        }
+        if (isNotEmptyArray(opts?.urls)) {
+            return this.locale$.pipe(mergeMap((locale) => this.loadAll(opts.urls, { locale, ...opts })));
+        }
+        return this.feedUrls$.pipe(filter(isNotEmptyArray), mergeMap((urls) => this.loadAll(urls, opts)));
+    }
+    getHomeUrl(feed) {
+        const feedUrl = feed?.feed_url ?? firstArrayValue(this.feedUrls);
+        return feedUrl ? UrlUtils.getRootUrl(feedUrl) : undefined;
+    }
+    getTagUrl(feed, tag) {
+        if (!feed || !tag)
+            throw new Error("Missing 'feed' or 'tag' argument");
+        const baseUrl = this.getHomeUrl(feed);
+        return feed.tag_template?.replace('{tag}', tag) ?? baseUrl + '/tag/' + tag;
+    }
+    async load(url, opts) {
+        const { data } = await this.loadAll([url], opts);
+        return data?.[0];
+    }
+    async loadAll(urls, opts) {
+        await this.ready();
+        urls = urls ?? this.feedUrls;
+        opts = {
+            maxAgeInMonths: opts?.maxAgeInMonths ?? this.environment.feed?.maxAgeInMonths,
+            maxContentLength: opts?.maxContentLength ?? this.environment.feed?.maxContentLength,
+            locale: this.settings.locale,
+            depth: 0,
+            ...opts,
+        };
+        const feeds = await Promise.all((urls || []).map(async (url) => {
+            try {
+                // Get JSON
+                const json = await this.network.fetch(url);
+                console.debug(`${this._logPrefix}Loaded JSON from ${url}`, json);
+                // Resolve feed
+                return await this.resolveFeed(json, url, opts);
+            }
+            catch (err) {
+                if (err?.status === 404) {
+                    console.error(`${this._logPrefix} Error while fetching feeds at ${url}. 404 (Not found)`);
+                }
+                else {
+                    console.error(`${this._logPrefix} Error while fetching feeds at ${url}`, err);
+                }
+                return Promise.resolve([]);
+            }
+        }));
+        const data = feeds.flat();
+        // Close opened resources
+        if (opts.depth === 0) {
+            this.onAfterLoadAll();
+        }
+        return { data, total: data.length };
+    }
+    async resolveFeed(json, url, opts) {
+        // Check json is JsonFeed compatible
+        if (JsonFeedUtils.isJsonFeed(json)) {
+            // Migrate from old versions
+            let feed = JsonFeedUtils.migrateFeed(json);
+            // Resolve items (e.g. using feed.next_url)
+            feed = await this.resolveFeedItems(feed, { ...opts, depth: opts?.depth ?? 0 });
+            // Truncate html
+            JsonFeedUtils.truncateFeedItemsHtml(feed, opts);
+            return isNotEmptyArray(feed?.items) ? [feed] : [];
+        }
+        // not resolved (unknown format)
+        return undefined;
+    }
+    async resolveFeedItems(json, opts) {
+        if (!json)
+            return json;
+        // Load items
+        if (isEmptyArray(json.items) && isNotNilOrBlank(json.next_url)) {
+            const depth = opts?.depth ?? 0;
+            if (depth >= 3) {
+                console.warn(`${this._logPrefix}Max depth reached (${depth}) for ${json.feed_url}`);
+                return json;
+            }
+            // Load items
+            const feed = await this.load(json.next_url, { ...opts, depth: depth + 1 });
+            if (isEmptyArray(feed?.items)) {
+                return json;
+            }
+            // Merge with the input json
+            return {
+                ...json,
+                title: json.title ?? feed.title,
+                home_page_url: json.home_page_url ?? feed.home_page_url,
+                authors: isNotEmptyArray(json.authors) ? json.authors : feed.authors,
+                items: feed.items,
+                tag_template: json.tag_template ?? feed.tag_template,
+            };
+        }
+        return json;
+    }
+    onAfterLoadAll() {
+        console.debug(`${this._logPrefix}Feeds loaded`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FeedService, deps: [{ token: i1.LocalSettingsService }, { token: ENVIRONMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FeedService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FeedService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.LocalSettingsService }, { type: i2.Environment, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"feed.service.js","sourceRoot":"","sources":["../../../../../../src/app/social/feed/feed.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { from, Observable, switchMap } from 'rxjs';\nimport { LoadResult } from '../../shared/services/entity-service.class';\nimport { JsonFeed, JsonFeedUtils } from './feed.model';\nimport { Inject, inject, Injectable, InjectionToken, Optional } from '@angular/core';\n\nimport { firstArrayValue, isEmptyArray, isNotEmptyArray, isNotNilOrBlank } from '../../shared/functions';\nimport { filter, map, mergeMap } from 'rxjs/operators';\nimport { StartableService } from '../../shared/services/startable-service.class';\nimport { NetworkService } from '../../core/services/network.service';\nimport { LocalSettingsService } from '../../core/services/local-settings.service';\nimport { RxState } from '@rx-angular/state';\nimport { ENVIRONMENT, Environment } from '../../../environments/environment.class';\nimport { UrlUtils } from '../../shared/file/url.utils';\n\nexport const APP_FEED_SERVICE = new InjectionToken<IFeedService<any>>('FeeService');\n\nexport interface IFeedService<T extends JsonFeed = JsonFeed> {\n  watchAll(opts?: { urls?: string[]; maxAgeInMonths?: number; maxContentLength?: number }): Observable<LoadResult<T>>;\n\n  getHomeUrl(feed?: T): string;\n\n  getTagUrl(feed: T, tag: string): string;\n}\n\nexport interface FeedServiceState {\n  locale: string;\n  feedUrls?: string[];\n}\n\n@Injectable()\nexport class FeedService<S extends FeedServiceState> extends StartableService<S> implements IFeedService {\n  protected _logPrefix = '[feed-service] ';\n  protected _state = new RxState<S>();\n  protected network = inject(NetworkService);\n\n  locale$ = this._state.select('locale');\n  feedUrls$ = this._state.select('feedUrls');\n\n  get feedUrls(): string[] {\n    return this._state.get('feedUrls');\n  }\n\n  set feedUrls(urls: string[]) {\n    this._state.set('feedUrls', () => urls);\n  }\n\n  constructor(\n    private settings: LocalSettingsService,\n    @Optional() @Inject(ENVIRONMENT) protected environment: Environment\n  ) {\n    super(settings);\n\n    this._state.connect('locale', this.settings.locale$);\n\n    this._state.connect(\n      'feedUrls',\n      this.locale$.pipe(\n        filter(isNotNilOrBlank),\n        map((locale) => (locale && environment.feed?.jsonFeed?.[locale]) ?? [])\n      )\n    );\n\n    // DEBUG\n    this._debug = !environment.production;\n    if (this._debug) console.debug(`${this._logPrefix}created`);\n  }\n\n  protected async ngOnStart(): Promise<S> {\n    await this.settings.ready();\n    return <S>{\n      locale: this.settings.locale,\n    };\n  }\n\n  watchAll(opts?: { urls?: string[]; maxAgeInMonths?: number; maxContentLength?: number }): Observable<LoadResult<JsonFeed>> {\n    if (!this.started) {\n      return from(this.start()).pipe(switchMap(() => this.watchAll(opts)));\n    }\n    if (isNotEmptyArray(opts?.urls)) {\n      return this.locale$.pipe(mergeMap((locale) => this.loadAll(opts.urls, { locale, ...opts })));\n    }\n    return this.feedUrls$.pipe(\n      filter(isNotEmptyArray),\n      mergeMap((urls) => this.loadAll(urls, opts))\n    );\n  }\n\n  getHomeUrl(feed?: JsonFeed) {\n    const feedUrl = feed?.feed_url ?? firstArrayValue(this.feedUrls);\n    return feedUrl ? UrlUtils.getRootUrl(feedUrl) : undefined;\n  }\n\n  getTagUrl(feed: JsonFeed, tag: string): string {\n    if (!feed || !tag) throw new Error(\"Missing 'feed' or 'tag' argument\");\n    const baseUrl = this.getHomeUrl(feed);\n    return feed.tag_template?.replace('{tag}', tag) ?? baseUrl + '/tag/' + tag;\n  }\n\n  async load(\n    url: string,\n    opts?: {\n      locale?: string;\n      maxAgeInMonths?: number;\n      maxContentLength?: number;\n      // Internal options (for recursive calls)\n      depth?: number;\n    }\n  ): Promise<JsonFeed> {\n    const { data } = await this.loadAll([url], opts);\n    return data?.[0];\n  }\n\n  async loadAll(\n    urls?: string[],\n    opts?: {\n      locale?: string;\n      maxAgeInMonths?: number;\n      maxContentLength?: number;\n      // Internal options (for recursive calls)\n      depth?: number;\n      [key: string]: any;\n    }\n  ): Promise<LoadResult<JsonFeed>> {\n    await this.ready();\n    urls = urls ?? this.feedUrls;\n    opts = {\n      maxAgeInMonths: opts?.maxAgeInMonths ?? this.environment.feed?.maxAgeInMonths,\n      maxContentLength: opts?.maxContentLength ?? this.environment.feed?.maxContentLength,\n      locale: this.settings.locale,\n      depth: 0,\n      ...opts,\n    };\n    const feeds = await Promise.all(\n      (urls || []).map(async (url) => {\n        try {\n          // Get JSON\n          const json = await this.network.fetch(url);\n          console.debug(`${this._logPrefix}Loaded JSON from ${url}`, json);\n\n          // Resolve feed\n          return await this.resolveFeed(json, url, opts);\n        } catch (err) {\n          if (err?.status === 404) {\n            console.error(`${this._logPrefix} Error while fetching feeds at ${url}. 404 (Not found)`);\n          } else {\n            console.error(`${this._logPrefix} Error while fetching feeds at ${url}`, err);\n          }\n          return Promise.resolve([]);\n        }\n      })\n    );\n\n    const data = feeds.flat();\n\n    // Close opened resources\n    if (opts.depth === 0) {\n      this.onAfterLoadAll();\n    }\n\n    return { data, total: data.length };\n  }\n\n  protected async resolveFeed(\n    json: any,\n    url: string,\n    opts?: {\n      locale?: string;\n      maxAgeInMonths?: number;\n      maxContentLength?: number;\n      // Internal options (for recursive calls)\n      depth?: number;\n      [key: string]: any;\n    }\n  ): Promise<JsonFeed[]> {\n    // Check json is JsonFeed compatible\n    if (JsonFeedUtils.isJsonFeed(json)) {\n      // Migrate from old versions\n      let feed = JsonFeedUtils.migrateFeed(json);\n\n      // Resolve items (e.g. using feed.next_url)\n      feed = await this.resolveFeedItems(feed, { ...opts, depth: opts?.depth ?? 0 });\n\n      // Truncate html\n      JsonFeedUtils.truncateFeedItemsHtml(feed, opts);\n\n      return isNotEmptyArray(feed?.items) ? [feed] : [];\n    }\n\n    // not resolved (unknown format)\n    return undefined;\n  }\n\n  protected async resolveFeedItems(\n    json: JsonFeed,\n    opts?: {\n      maxContentLength?: number;\n      depth?: number;\n    }\n  ): Promise<JsonFeed> {\n    if (!json) return json;\n\n    // Load items\n    if (isEmptyArray(json.items) && isNotNilOrBlank(json.next_url)) {\n      const depth = opts?.depth ?? 0;\n      if (depth >= 3) {\n        console.warn(`${this._logPrefix}Max depth reached (${depth}) for ${json.feed_url}`);\n        return json;\n      }\n\n      // Load items\n      const feed = await this.load(json.next_url, { ...opts, depth: depth + 1 });\n\n      if (isEmptyArray(feed?.items)) {\n        return json;\n      }\n\n      // Merge with the input json\n      return {\n        ...json,\n        title: json.title ?? feed.title,\n        home_page_url: json.home_page_url ?? feed.home_page_url,\n        authors: isNotEmptyArray(json.authors) ? json.authors : feed.authors,\n        items: feed.items,\n        tag_template: json.tag_template ?? feed.tag_template,\n      };\n    }\n\n    return json;\n  }\n\n  protected onAfterLoadAll() {\n    console.debug(`${this._logPrefix}Feeds loaded`);\n  }\n}\n"]}

package/esm2022/src/app/social/message/message.form.mjs

@@ -20,6 +20,7 @@ import * as i9 from "@angular/material/core";
 import * as i10 from "../../shared/material/chips/material.chips";
 import * as i11 from "../../shared/directives/autoresize.directive";
 import * as i12 from "@angular/material/chips";
+import * as i13 from "../../shared/pipes/form.pipes";
 export class MessageForm extends AppForm {
     formBuilder;
     cd;
@@ -116,11 +117,11 @@ export class MessageForm extends AppForm {
         this.cd.markForCheck();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessageForm, deps: [{ token: i0.Injector }, { token: i1.UntypedFormBuilder }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: MessageForm, selector: "app-message-form", inputs: { suggestFn: "suggestFn", subjectMinLength: "subjectMinLength", subjectMaxLength: "subjectMaxLength", bodyMaxLength: "bodyMaxLength", bodyAutoHeight: "bodyAutoHeight", canSelectType: "canSelectType", canRecipientFilter: "canRecipientFilter", recipientFilterCount: "recipientFilterCount" }, usesInheritance: true, ngImport: i0, template: "<form [formGroup]=\"form\" class=\"form-container\">\n  <!-- type -->\n  <mat-form-field *ngIf=\"canSelectType\">\n    <mat-label>{{ 'SOCIAL.MESSAGE.TYPE' | translate }}</mat-label>\n    <mat-select formControlName=\"type\">\n      <ng-container *ngFor=\"let item of types\">\n        <mat-option [value]=\"item.id\" *ngIf=\"item.id !== 'FEED' || canRecipientFilter\">\n          <ion-icon [name]=\"item.icon\"></ion-icon>\n          {{ item.label | translate }}\n        </mat-option>\n      </ng-container>\n    </mat-select>\n  </mat-form-field>\n\n  <!-- Recipients -->\n  <mat-chips-field\n    *ngIf=\"(form.controls.type.valueChanges | async) !== 'FEED'; else recipientFilter\"\n    formControlName=\"recipients\"\n    chipColor=\"accent\"\n    [placeholder]=\"'SOCIAL.MESSAGE.RECIPIENTS' | translate\"\n    [config]=\"autocompleteFields.recipients\"\n    [equals]=\"isSamePerson\"\n  ></mat-chips-field>\n  <ng-template #recipientFilter>\n    <mat-form-field>\n      <mat-chip-grid>\n        <mat-chip-row>\n          {{ 'SOCIAL.MESSAGE.RECIPIENT_FILTER_COUNT' | translate: { count: recipientFilterCount } }}\n        </mat-chip-row>\n      </mat-chip-grid>\n      <input matInput hidden type=\"number\" />\n    </mat-form-field>\n  </ng-template>\n\n  <!-- Subject -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.SUBJECT' | translate }}</mat-label>\n    <input matInput type=\"text\" formControlName=\"subject\" autocomplete=\"off\" required />\n    <mat-error *ngIf=\"form.controls.subject.hasError('required')\" translate>ERROR.FIELD_REQUIRED</mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('minlength')\">\n      {{ 'ERROR.FIELD_MIN_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-hint *ngIf=\"subjectMaxLength\" align=\"end\">\n      {{\n        'INFO.TEXT_PROGRESS' | translate: { current: form.controls.subject.value?.length || 0, max: subjectMaxLength }\n      }}\n    </mat-hint>\n  </mat-form-field>\n\n  <!-- Body -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.BODY_HELP' | translate }}</mat-label>\n    <textarea\n      matInput\n      type=\"text\"\n      formControlName=\"body\"\n      [class.fixed-height]=\"!bodyAutoHeight\"\n      [cdkTextareaAutosize]=\"bodyAutoHeight\"\n      (keydown.control.enter)=\"doSubmit($event)\"\n    ></textarea>\n    <mat-error *ngIf=\"form.controls.body.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH' | translate: form.controls.body.errors.maxlength }}\n    </mat-error>\n    <mat-hint *ngIf=\"bodyMaxLength\" align=\"end\">\n      {{ 'INFO.TEXT_PROGRESS' | translate: { current: form.controls.body.value?.length || 0, max: bodyMaxLength } }}\n    </mat-hint>\n  </mat-form-field>\n</form>\n", styles: ["textarea.fixed-height{height:11.5em}textarea{min-height:11.5em}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "directive", type: i4.TranslateDirective, selector: "[translate],[ngx-translate]", inputs: ["translate", "translateParams"] }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i5.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i5.MatLabel, selector: "mat-label" }, { kind: "directive", type: i5.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { kind: "directive", type: i5.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "directive", type: i6.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "directive", type: i7.CdkTextareaAutosize, selector: "textarea[cdkTextareaAutosize]", inputs: ["cdkAutosizeMinRows", "cdkAutosizeMaxRows", "cdkTextareaAutosize", "placeholder"], exportAs: ["cdkTextareaAutosize"] }, { kind: "component", type: i8.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i9.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "component", type: i10.MatChipsField, selector: "mat-chips-field", inputs: ["equals", "logPrefix", "formControl", "formControlName", "floatLabel", "placeholder", "suggestFn", "required", "mobile", "readonly", "clearable", "debounceTime", "displaySeparator", "displayWith", "displayAttributes", "displayColumnSizes", "displayColumnNames", "highlightAccent", "showAllOnFocus", "showPanelOnFocus", "autofocus", "config", "i18nPrefix", "noResultMessage", "panelClass", "panelWidth", "disableRipple", "matAutocompletePosition", "itemSize", "fetchMoreThreshold", "suggestLengthThreshold", "showLoadingSpinner", "chipColor", "debug", "applyImplicitValue", "dropButtonTitle", "clearButtonTitle", "trimSearchText", "hideRequiredMarker", "colSizes", "separatorKeysCodes", "appearance", "subscriptSizing", "class", "filter", "tabindex", "items"], outputs: ["click", "blur", "focus", "dropButtonClick", "keydown.escape", "keyup.enter"] }, { kind: "directive", type: i11.AutoResizeDirective, selector: "textarea[cdkTextareaAutosize]", inputs: ["cdkAutosizeMaxRows", "cdkAutosizeMinRows"] }, { kind: "component", type: i12.MatChipGrid, selector: "mat-chip-grid", inputs: ["disabled", "placeholder", "required", "value", "errorStateMatcher"], outputs: ["change", "valueChange"] }, { kind: "component", type: i12.MatChipRow, selector: "mat-chip-row, [mat-chip-row], mat-basic-chip-row, [mat-basic-chip-row]", inputs: ["editable"], outputs: ["edited"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: MessageForm, selector: "app-message-form", inputs: { suggestFn: "suggestFn", subjectMinLength: "subjectMinLength", subjectMaxLength: "subjectMaxLength", bodyMaxLength: "bodyMaxLength", bodyAutoHeight: "bodyAutoHeight", canSelectType: "canSelectType", canRecipientFilter: "canRecipientFilter", recipientFilterCount: "recipientFilterCount" }, usesInheritance: true, ngImport: i0, template: "<form [formGroup]=\"form\" class=\"form-container\">\n  <!-- type -->\n  <mat-form-field *ngIf=\"canSelectType\">\n    <mat-label>{{ 'SOCIAL.MESSAGE.TYPE' | translate }}</mat-label>\n    <mat-select formControlName=\"type\">\n      @for (item of types; track item.id) {\n        @if (canRecipientFilter || item.id !== 'FEED') {\n          <mat-option [value]=\"item.id\">\n            <ion-icon [name]=\"item.icon\"></ion-icon>\n            {{ item.label | translate }}\n          </mat-option>\n        }\n      }\n    </mat-select>\n  </mat-form-field>\n\n  <!-- Recipients -->\n  @if ((form | formGetValue: 'type') !== 'FEED') {\n    <mat-chips-field\n      formControlName=\"recipients\"\n      chipColor=\"accent\"\n      [placeholder]=\"'SOCIAL.MESSAGE.RECIPIENTS' | translate\"\n      [config]=\"autocompleteFields.recipients\"\n      [equals]=\"isSamePerson\"\n    ></mat-chips-field>\n  } @else {\n    <mat-form-field>\n      <input matInput hidden formControlName=\"recipients\" type=\"text\" />\n      <mat-chip-grid>\n        <mat-chip-row>\n          {{ 'SOCIAL.MESSAGE.RECIPIENT_FILTER_COUNT' | translate: { count: recipientFilterCount } }}\n        </mat-chip-row>\n      </mat-chip-grid>\n    </mat-form-field>\n  }\n\n  <!-- Subject -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.SUBJECT' | translate }}</mat-label>\n    <input matInput type=\"text\" formControlName=\"subject\" autocomplete=\"off\" required />\n    <mat-error *ngIf=\"form.controls.subject.hasError('required')\" translate>ERROR.FIELD_REQUIRED</mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('minlength')\">\n      {{ 'ERROR.FIELD_MIN_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-hint *ngIf=\"subjectMaxLength\" align=\"end\">\n      {{\n        'INFO.TEXT_PROGRESS' | translate: { current: form.controls.subject.value?.length || 0, max: subjectMaxLength }\n      }}\n    </mat-hint>\n  </mat-form-field>\n\n  <!-- Body -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.BODY_HELP' | translate }}</mat-label>\n    <textarea\n      matInput\n      type=\"text\"\n      formControlName=\"body\"\n      [class.fixed-height]=\"!bodyAutoHeight\"\n      [cdkTextareaAutosize]=\"bodyAutoHeight\"\n      (keydown.control.enter)=\"doSubmit($event)\"\n    ></textarea>\n    <mat-error *ngIf=\"form.controls.body.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH' | translate: form.controls.body.errors.maxlength }}\n    </mat-error>\n    <mat-hint *ngIf=\"bodyMaxLength\" align=\"end\">\n      {{ 'INFO.TEXT_PROGRESS' | translate: { current: form.controls.body.value?.length || 0, max: bodyMaxLength } }}\n    </mat-hint>\n  </mat-form-field>\n</form>\n", styles: ["textarea.fixed-height{height:11.5em}textarea{min-height:11.5em}\n"], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "directive", type: i4.TranslateDirective, selector: "[translate],[ngx-translate]", inputs: ["translate", "translateParams"] }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i5.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i5.MatLabel, selector: "mat-label" }, { kind: "directive", type: i5.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { kind: "directive", type: i5.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "directive", type: i6.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "directive", type: i7.CdkTextareaAutosize, selector: "textarea[cdkTextareaAutosize]", inputs: ["cdkAutosizeMinRows", "cdkAutosizeMaxRows", "cdkTextareaAutosize", "placeholder"], exportAs: ["cdkTextareaAutosize"] }, { kind: "component", type: i8.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i9.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "component", type: i10.MatChipsField, selector: "mat-chips-field", inputs: ["equals", "logPrefix", "formControl", "formControlName", "floatLabel", "placeholder", "suggestFn", "required", "mobile", "readonly", "clearable", "debounceTime", "displaySeparator", "displayWith", "displayAttributes", "displayColumnSizes", "displayColumnNames", "highlightAccent", "showAllOnFocus", "showPanelOnFocus", "autofocus", "config", "i18nPrefix", "noResultMessage", "panelClass", "panelWidth", "disableRipple", "matAutocompletePosition", "itemSize", "fetchMoreThreshold", "suggestLengthThreshold", "showLoadingSpinner", "chipColor", "debug", "applyImplicitValue", "dropButtonTitle", "clearButtonTitle", "trimSearchText", "hideRequiredMarker", "colSizes", "separatorKeysCodes", "appearance", "subscriptSizing", "class", "filter", "tabindex", "items"], outputs: ["click", "blur", "focus", "dropButtonClick", "keydown.escape", "keyup.enter"] }, { kind: "directive", type: i11.AutoResizeDirective, selector: "textarea[cdkTextareaAutosize]", inputs: ["cdkAutosizeMaxRows", "cdkAutosizeMinRows"] }, { kind: "component", type: i12.MatChipGrid, selector: "mat-chip-grid", inputs: ["disabled", "placeholder", "required", "value", "errorStateMatcher"], outputs: ["change", "valueChange"] }, { kind: "component", type: i12.MatChipRow, selector: "mat-chip-row, [mat-chip-row], mat-basic-chip-row, [mat-basic-chip-row]", inputs: ["editable"], outputs: ["edited"] }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }, { kind: "pipe", type: i13.FormGetValuePipe, name: "formGetValue" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MessageForm, decorators: [{
             type: Component,
-            args: [{ selector: 'app-message-form', changeDetection: ChangeDetectionStrategy.OnPush, template: "<form [formGroup]=\"form\" class=\"form-container\">\n  <!-- type -->\n  <mat-form-field *ngIf=\"canSelectType\">\n    <mat-label>{{ 'SOCIAL.MESSAGE.TYPE' | translate }}</mat-label>\n    <mat-select formControlName=\"type\">\n      <ng-container *ngFor=\"let item of types\">\n        <mat-option [value]=\"item.id\" *ngIf=\"item.id !== 'FEED' || canRecipientFilter\">\n          <ion-icon [name]=\"item.icon\"></ion-icon>\n          {{ item.label | translate }}\n        </mat-option>\n      </ng-container>\n    </mat-select>\n  </mat-form-field>\n\n  <!-- Recipients -->\n  <mat-chips-field\n    *ngIf=\"(form.controls.type.valueChanges | async) !== 'FEED'; else recipientFilter\"\n    formControlName=\"recipients\"\n    chipColor=\"accent\"\n    [placeholder]=\"'SOCIAL.MESSAGE.RECIPIENTS' | translate\"\n    [config]=\"autocompleteFields.recipients\"\n    [equals]=\"isSamePerson\"\n  ></mat-chips-field>\n  <ng-template #recipientFilter>\n    <mat-form-field>\n      <mat-chip-grid>\n        <mat-chip-row>\n          {{ 'SOCIAL.MESSAGE.RECIPIENT_FILTER_COUNT' | translate: { count: recipientFilterCount } }}\n        </mat-chip-row>\n      </mat-chip-grid>\n      <input matInput hidden type=\"number\" />\n    </mat-form-field>\n  </ng-template>\n\n  <!-- Subject -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.SUBJECT' | translate }}</mat-label>\n    <input matInput type=\"text\" formControlName=\"subject\" autocomplete=\"off\" required />\n    <mat-error *ngIf=\"form.controls.subject.hasError('required')\" translate>ERROR.FIELD_REQUIRED</mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('minlength')\">\n      {{ 'ERROR.FIELD_MIN_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-hint *ngIf=\"subjectMaxLength\" align=\"end\">\n      {{\n        'INFO.TEXT_PROGRESS' | translate: { current: form.controls.subject.value?.length || 0, max: subjectMaxLength }\n      }}\n    </mat-hint>\n  </mat-form-field>\n\n  <!-- Body -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.BODY_HELP' | translate }}</mat-label>\n    <textarea\n      matInput\n      type=\"text\"\n      formControlName=\"body\"\n      [class.fixed-height]=\"!bodyAutoHeight\"\n      [cdkTextareaAutosize]=\"bodyAutoHeight\"\n      (keydown.control.enter)=\"doSubmit($event)\"\n    ></textarea>\n    <mat-error *ngIf=\"form.controls.body.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH' | translate: form.controls.body.errors.maxlength }}\n    </mat-error>\n    <mat-hint *ngIf=\"bodyMaxLength\" align=\"end\">\n      {{ 'INFO.TEXT_PROGRESS' | translate: { current: form.controls.body.value?.length || 0, max: bodyMaxLength } }}\n    </mat-hint>\n  </mat-form-field>\n</form>\n", styles: ["textarea.fixed-height{height:11.5em}textarea{min-height:11.5em}\n"] }]
+            args: [{ selector: 'app-message-form', changeDetection: ChangeDetectionStrategy.OnPush, template: "<form [formGroup]=\"form\" class=\"form-container\">\n  <!-- type -->\n  <mat-form-field *ngIf=\"canSelectType\">\n    <mat-label>{{ 'SOCIAL.MESSAGE.TYPE' | translate }}</mat-label>\n    <mat-select formControlName=\"type\">\n      @for (item of types; track item.id) {\n        @if (canRecipientFilter || item.id !== 'FEED') {\n          <mat-option [value]=\"item.id\">\n            <ion-icon [name]=\"item.icon\"></ion-icon>\n            {{ item.label | translate }}\n          </mat-option>\n        }\n      }\n    </mat-select>\n  </mat-form-field>\n\n  <!-- Recipients -->\n  @if ((form | formGetValue: 'type') !== 'FEED') {\n    <mat-chips-field\n      formControlName=\"recipients\"\n      chipColor=\"accent\"\n      [placeholder]=\"'SOCIAL.MESSAGE.RECIPIENTS' | translate\"\n      [config]=\"autocompleteFields.recipients\"\n      [equals]=\"isSamePerson\"\n    ></mat-chips-field>\n  } @else {\n    <mat-form-field>\n      <input matInput hidden formControlName=\"recipients\" type=\"text\" />\n      <mat-chip-grid>\n        <mat-chip-row>\n          {{ 'SOCIAL.MESSAGE.RECIPIENT_FILTER_COUNT' | translate: { count: recipientFilterCount } }}\n        </mat-chip-row>\n      </mat-chip-grid>\n    </mat-form-field>\n  }\n\n  <!-- Subject -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.SUBJECT' | translate }}</mat-label>\n    <input matInput type=\"text\" formControlName=\"subject\" autocomplete=\"off\" required />\n    <mat-error *ngIf=\"form.controls.subject.hasError('required')\" translate>ERROR.FIELD_REQUIRED</mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('minlength')\">\n      {{ 'ERROR.FIELD_MIN_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-hint *ngIf=\"subjectMaxLength\" align=\"end\">\n      {{\n        'INFO.TEXT_PROGRESS' | translate: { current: form.controls.subject.value?.length || 0, max: subjectMaxLength }\n      }}\n    </mat-hint>\n  </mat-form-field>\n\n  <!-- Body -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.BODY_HELP' | translate }}</mat-label>\n    <textarea\n      matInput\n      type=\"text\"\n      formControlName=\"body\"\n      [class.fixed-height]=\"!bodyAutoHeight\"\n      [cdkTextareaAutosize]=\"bodyAutoHeight\"\n      (keydown.control.enter)=\"doSubmit($event)\"\n    ></textarea>\n    <mat-error *ngIf=\"form.controls.body.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH' | translate: form.controls.body.errors.maxlength }}\n    </mat-error>\n    <mat-hint *ngIf=\"bodyMaxLength\" align=\"end\">\n      {{ 'INFO.TEXT_PROGRESS' | translate: { current: form.controls.body.value?.length || 0, max: bodyMaxLength } }}\n    </mat-hint>\n  </mat-form-field>\n</form>\n", styles: ["textarea.fixed-height{height:11.5em}textarea{min-height:11.5em}\n"] }]
         }], ctorParameters: () => [{ type: i0.Injector }, { type: i1.UntypedFormBuilder }, { type: i0.ChangeDetectorRef }], propDecorators: { suggestFn: [{
                 type: Input
             }], subjectMinLength: [{
@@ -138,4 +139,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
             }], recipientFilterCount: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message.form.js","sourceRoot":"","sources":["../../../../../../src/app/social/message/message.form.ts","../../../../../../src/app/social/message/message.form.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Injector, Input, OnInit } from '@angular/core';\nimport { UntypedFormBuilder, UntypedFormGroup, Validators } from '@angular/forms';\nimport { Message, MessageTypeList, MessageTypes } from './message.model';\nimport { AppForm } from '../../core/form/form.class';\nimport { StatusIds } from '../../core/services/model/model.enum';\nimport { Person, PersonUtils } from '../../core/services/model/person.model';\nimport { SuggestFn } from '../../shared/services/entity-service.class';\nimport { PersonFilter } from '../../admin/services/filter/person.filter';\nimport { EntityUtils } from '../../core/services/model/entity.model';\nimport { changeCaseToUnderscore, isNotNil, toBoolean } from '../../shared/functions';\nimport { filter } from 'rxjs/operators';\n\n@Component({\n  selector: 'app-message-form',\n  templateUrl: './message.form.html',\n  styleUrls: ['./message.form.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MessageForm extends AppForm<Message> implements OnInit {\n  readonly mobile: boolean;\n\n  @Input() suggestFn: SuggestFn<Person, PersonFilter>;\n  @Input() subjectMinLength = 5;\n  @Input() subjectMaxLength = 255;\n  @Input() bodyMaxLength = 2000;\n  @Input() bodyAutoHeight = true;\n  @Input() canSelectType = false;\n  @Input() canRecipientFilter = false;\n  @Input() recipientFilterCount = 0;\n\n  types = MessageTypeList;\n\n  constructor(\n    injector: Injector,\n    private formBuilder: UntypedFormBuilder,\n    private readonly cd: ChangeDetectorRef\n  ) {\n    super(injector);\n    this.mobile = this.settings.mobile;\n  }\n\n  ngOnInit() {\n    this.setForm(\n      this.formBuilder.group({\n        type: [MessageTypes.INBOX_MESSAGE, Validators.required],\n        recipients: [null, Validators.required],\n        recipientFilter: [null],\n        subject: [\n          null,\n          this.subjectMaxLength\n            ? Validators.compose([Validators.required, Validators.minLength(this.subjectMinLength), Validators.maxLength(this.subjectMaxLength)])\n            : Validators.required,\n        ],\n        body: [null, this.bodyMaxLength ? Validators.compose([Validators.maxLength(this.bodyMaxLength)]) : Validators.required],\n      })\n    );\n\n    this.registerSubscription(\n      this._form\n        .get('type')\n        .valueChanges.pipe(filter(isNotNil))\n        .subscribe((type) => this.updateFormGroup(this._form, { type }))\n    );\n\n    // Person combo\n    const personAttributes = this.settings.getFieldDisplayAttributes('person', ['lastName', 'firstName', 'department.name']);\n    this.registerAutocompleteField('recipients', {\n      showAllOnFocus: false,\n      suggestFn: this.suggestFn,\n      filter: {\n        statusIds: [StatusIds.TEMPORARY, StatusIds.ENABLE],\n      },\n      attributes: personAttributes,\n      columnNames: personAttributes.map((attr) => `USER.${changeCaseToUnderscore(attr).toUpperCase()}`),\n      displayWith: PersonUtils.personToString,\n      multiple: true,\n      mobile: this.mobile,\n    });\n  }\n\n  isSamePerson(o1: Person, o2: Person): boolean {\n    return EntityUtils.equals(o1, o2, 'id');\n  }\n\n  protected updateFormGroup(formGroup: UntypedFormGroup, opts?: { type?: string; recipientRequired?: boolean }) {\n    console.debug('[message-form] Updating form group...', opts);\n\n    // Recipient validator\n    const recipientsRequired = toBoolean(opts?.recipientRequired, opts?.type !== MessageTypes.FEED);\n    {\n      const control = formGroup.get('recipients');\n      if (recipientsRequired) {\n        if (!control.hasValidator(Validators.required)) {\n          control.addValidators(Validators.required);\n        }\n        control.enable();\n      } else {\n        if (control.hasValidator(Validators.required)) {\n          control.removeValidators(Validators.required);\n        }\n        control.disable();\n      }\n    }\n\n    // Recipient filter validator\n    const recipientFilterRequired = this.canRecipientFilter && !recipientsRequired;\n    {\n      const control = formGroup.get('recipientFilter');\n      if (recipientFilterRequired) {\n        if (!control.hasValidator(Validators.required)) {\n          control.addValidators(Validators.required);\n        }\n        control.enable();\n      } else {\n        if (control.hasValidator(Validators.required)) {\n          control.removeValidators(Validators.required);\n        }\n        control.disable();\n      }\n    }\n\n    formGroup.updateValueAndValidity();\n  }\n\n  protected markForCheck() {\n    this.cd.markForCheck();\n  }\n}\n","<form [formGroup]=\"form\" class=\"form-container\">\n  <!-- type -->\n  <mat-form-field *ngIf=\"canSelectType\">\n    <mat-label>{{ 'SOCIAL.MESSAGE.TYPE' | translate }}</mat-label>\n    <mat-select formControlName=\"type\">\n      <ng-container *ngFor=\"let item of types\">\n        <mat-option [value]=\"item.id\" *ngIf=\"item.id !== 'FEED' || canRecipientFilter\">\n          <ion-icon [name]=\"item.icon\"></ion-icon>\n          {{ item.label | translate }}\n        </mat-option>\n      </ng-container>\n    </mat-select>\n  </mat-form-field>\n\n  <!-- Recipients -->\n  <mat-chips-field\n    *ngIf=\"(form.controls.type.valueChanges | async) !== 'FEED'; else recipientFilter\"\n    formControlName=\"recipients\"\n    chipColor=\"accent\"\n    [placeholder]=\"'SOCIAL.MESSAGE.RECIPIENTS' | translate\"\n    [config]=\"autocompleteFields.recipients\"\n    [equals]=\"isSamePerson\"\n  ></mat-chips-field>\n  <ng-template #recipientFilter>\n    <mat-form-field>\n      <mat-chip-grid>\n        <mat-chip-row>\n          {{ 'SOCIAL.MESSAGE.RECIPIENT_FILTER_COUNT' | translate: { count: recipientFilterCount } }}\n        </mat-chip-row>\n      </mat-chip-grid>\n      <input matInput hidden type=\"number\" />\n    </mat-form-field>\n  </ng-template>\n\n  <!-- Subject -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.SUBJECT' | translate }}</mat-label>\n    <input matInput type=\"text\" formControlName=\"subject\" autocomplete=\"off\" required />\n    <mat-error *ngIf=\"form.controls.subject.hasError('required')\" translate>ERROR.FIELD_REQUIRED</mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('minlength')\">\n      {{ 'ERROR.FIELD_MIN_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-hint *ngIf=\"subjectMaxLength\" align=\"end\">\n      {{\n        'INFO.TEXT_PROGRESS' | translate: { current: form.controls.subject.value?.length || 0, max: subjectMaxLength }\n      }}\n    </mat-hint>\n  </mat-form-field>\n\n  <!-- Body -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.BODY_HELP' | translate }}</mat-label>\n    <textarea\n      matInput\n      type=\"text\"\n      formControlName=\"body\"\n      [class.fixed-height]=\"!bodyAutoHeight\"\n      [cdkTextareaAutosize]=\"bodyAutoHeight\"\n      (keydown.control.enter)=\"doSubmit($event)\"\n    ></textarea>\n    <mat-error *ngIf=\"form.controls.body.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH' | translate: form.controls.body.errors.maxlength }}\n    </mat-error>\n    <mat-hint *ngIf=\"bodyMaxLength\" align=\"end\">\n      {{ 'INFO.TEXT_PROGRESS' | translate: { current: form.controls.body.value?.length || 0, max: bodyMaxLength } }}\n    </mat-hint>\n  </mat-form-field>\n</form>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message.form.js","sourceRoot":"","sources":["../../../../../../src/app/social/message/message.form.ts","../../../../../../src/app/social/message/message.form.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Injector, Input, OnInit } from '@angular/core';\nimport { UntypedFormBuilder, UntypedFormGroup, Validators } from '@angular/forms';\nimport { Message, MessageTypeList, MessageTypes } from './message.model';\nimport { AppForm } from '../../core/form/form.class';\nimport { StatusIds } from '../../core/services/model/model.enum';\nimport { Person, PersonUtils } from '../../core/services/model/person.model';\nimport { SuggestFn } from '../../shared/services/entity-service.class';\nimport { PersonFilter } from '../../admin/services/filter/person.filter';\nimport { EntityUtils } from '../../core/services/model/entity.model';\nimport { changeCaseToUnderscore, isNotNil, toBoolean } from '../../shared/functions';\nimport { filter } from 'rxjs/operators';\n\n@Component({\n  selector: 'app-message-form',\n  templateUrl: './message.form.html',\n  styleUrls: ['./message.form.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MessageForm extends AppForm<Message> implements OnInit {\n  readonly mobile: boolean;\n\n  @Input() suggestFn: SuggestFn<Person, PersonFilter>;\n  @Input() subjectMinLength = 5;\n  @Input() subjectMaxLength = 255;\n  @Input() bodyMaxLength = 2000;\n  @Input() bodyAutoHeight = true;\n  @Input() canSelectType = false;\n  @Input() canRecipientFilter = false;\n  @Input() recipientFilterCount = 0;\n\n  types = MessageTypeList;\n\n  constructor(\n    injector: Injector,\n    private formBuilder: UntypedFormBuilder,\n    private readonly cd: ChangeDetectorRef\n  ) {\n    super(injector);\n    this.mobile = this.settings.mobile;\n  }\n\n  ngOnInit() {\n    this.setForm(\n      this.formBuilder.group({\n        type: [MessageTypes.INBOX_MESSAGE, Validators.required],\n        recipients: [null, Validators.required],\n        recipientFilter: [null],\n        subject: [\n          null,\n          this.subjectMaxLength\n            ? Validators.compose([Validators.required, Validators.minLength(this.subjectMinLength), Validators.maxLength(this.subjectMaxLength)])\n            : Validators.required,\n        ],\n        body: [null, this.bodyMaxLength ? Validators.compose([Validators.maxLength(this.bodyMaxLength)]) : Validators.required],\n      })\n    );\n\n    this.registerSubscription(\n      this._form\n        .get('type')\n        .valueChanges.pipe(filter(isNotNil))\n        .subscribe((type) => this.updateFormGroup(this._form, { type }))\n    );\n\n    // Person combo\n    const personAttributes = this.settings.getFieldDisplayAttributes('person', ['lastName', 'firstName', 'department.name']);\n    this.registerAutocompleteField('recipients', {\n      showAllOnFocus: false,\n      suggestFn: this.suggestFn,\n      filter: {\n        statusIds: [StatusIds.TEMPORARY, StatusIds.ENABLE],\n      },\n      attributes: personAttributes,\n      columnNames: personAttributes.map((attr) => `USER.${changeCaseToUnderscore(attr).toUpperCase()}`),\n      displayWith: PersonUtils.personToString,\n      multiple: true,\n      mobile: this.mobile,\n    });\n  }\n\n  isSamePerson(o1: Person, o2: Person): boolean {\n    return EntityUtils.equals(o1, o2, 'id');\n  }\n\n  protected updateFormGroup(formGroup: UntypedFormGroup, opts?: { type?: string; recipientRequired?: boolean }) {\n    console.debug('[message-form] Updating form group...', opts);\n\n    // Recipient validator\n    const recipientsRequired = toBoolean(opts?.recipientRequired, opts?.type !== MessageTypes.FEED);\n    {\n      const control = formGroup.get('recipients');\n      if (recipientsRequired) {\n        if (!control.hasValidator(Validators.required)) {\n          control.addValidators(Validators.required);\n        }\n        control.enable();\n      } else {\n        if (control.hasValidator(Validators.required)) {\n          control.removeValidators(Validators.required);\n        }\n        control.disable();\n      }\n    }\n\n    // Recipient filter validator\n    const recipientFilterRequired = this.canRecipientFilter && !recipientsRequired;\n    {\n      const control = formGroup.get('recipientFilter');\n      if (recipientFilterRequired) {\n        if (!control.hasValidator(Validators.required)) {\n          control.addValidators(Validators.required);\n        }\n        control.enable();\n      } else {\n        if (control.hasValidator(Validators.required)) {\n          control.removeValidators(Validators.required);\n        }\n        control.disable();\n      }\n    }\n\n    formGroup.updateValueAndValidity();\n  }\n\n  protected markForCheck() {\n    this.cd.markForCheck();\n  }\n}\n","<form [formGroup]=\"form\" class=\"form-container\">\n  <!-- type -->\n  <mat-form-field *ngIf=\"canSelectType\">\n    <mat-label>{{ 'SOCIAL.MESSAGE.TYPE' | translate }}</mat-label>\n    <mat-select formControlName=\"type\">\n      @for (item of types; track item.id) {\n        @if (canRecipientFilter || item.id !== 'FEED') {\n          <mat-option [value]=\"item.id\">\n            <ion-icon [name]=\"item.icon\"></ion-icon>\n            {{ item.label | translate }}\n          </mat-option>\n        }\n      }\n    </mat-select>\n  </mat-form-field>\n\n  <!-- Recipients -->\n  @if ((form | formGetValue: 'type') !== 'FEED') {\n    <mat-chips-field\n      formControlName=\"recipients\"\n      chipColor=\"accent\"\n      [placeholder]=\"'SOCIAL.MESSAGE.RECIPIENTS' | translate\"\n      [config]=\"autocompleteFields.recipients\"\n      [equals]=\"isSamePerson\"\n    ></mat-chips-field>\n  } @else {\n    <mat-form-field>\n      <input matInput hidden formControlName=\"recipients\" type=\"text\" />\n      <mat-chip-grid>\n        <mat-chip-row>\n          {{ 'SOCIAL.MESSAGE.RECIPIENT_FILTER_COUNT' | translate: { count: recipientFilterCount } }}\n        </mat-chip-row>\n      </mat-chip-grid>\n    </mat-form-field>\n  }\n\n  <!-- Subject -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.SUBJECT' | translate }}</mat-label>\n    <input matInput type=\"text\" formControlName=\"subject\" autocomplete=\"off\" required />\n    <mat-error *ngIf=\"form.controls.subject.hasError('required')\" translate>ERROR.FIELD_REQUIRED</mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('minlength')\">\n      {{ 'ERROR.FIELD_MIN_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-error *ngIf=\"form.controls.subject.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH_COMPACT' | translate }}\n    </mat-error>\n    <mat-hint *ngIf=\"subjectMaxLength\" align=\"end\">\n      {{\n        'INFO.TEXT_PROGRESS' | translate: { current: form.controls.subject.value?.length || 0, max: subjectMaxLength }\n      }}\n    </mat-hint>\n  </mat-form-field>\n\n  <!-- Body -->\n  <mat-form-field>\n    <mat-label>{{ 'SOCIAL.MESSAGE.BODY_HELP' | translate }}</mat-label>\n    <textarea\n      matInput\n      type=\"text\"\n      formControlName=\"body\"\n      [class.fixed-height]=\"!bodyAutoHeight\"\n      [cdkTextareaAutosize]=\"bodyAutoHeight\"\n      (keydown.control.enter)=\"doSubmit($event)\"\n    ></textarea>\n    <mat-error *ngIf=\"form.controls.body.hasError('maxlength')\">\n      {{ 'ERROR.FIELD_MAX_LENGTH' | translate: form.controls.body.errors.maxlength }}\n    </mat-error>\n    <mat-hint *ngIf=\"bodyMaxLength\" align=\"end\">\n      {{ 'INFO.TEXT_PROGRESS' | translate: { current: form.controls.body.value?.length || 0, max: bodyMaxLength } }}\n    </mat-hint>\n  </mat-form-field>\n</form>\n"]}

package/esm2022/src/app/social/message/message.model.mjs

@@ -22,7 +22,7 @@ export const MessageTypeList = Object.freeze([
     },
     {
         id: MessageTypes.FEED,
-        icon: 'paper',
+        icon: 'megaphone',
         label: 'SOCIAL.MESSAGE.TYPE_ENUM.FEED',
     },
 ]);
@@ -72,4 +72,4 @@ MessageFilter = __decorate([
     EntityClass({ typename: 'MessageFilterVO' })
 ], MessageFilter);
 export { MessageFilter };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/environments/environment.mjs

@@ -109,8 +109,10 @@ export const environment = Object.freeze({
         jsonFeed: {
             fr: [
                 'https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components/-/raw/master/doc/feed/feed-fr.json',
-                //'https://raw.githubusercontent.com/duniter/cesium/master/doc/feed/1.1/feed-fr-FR.json',
+                // Example with JsonFeed version 1 (and not 1.1)
                 //'https://raw.githubusercontent.com/duniter/cesium/master/doc/feed/feed-fr.json',
+                // Example with discourse API :
+                //'https://raw.githubusercontent.com/duniter/cesium/master/doc/feed/1.1/feed-fr-FR.json',
             ],
             en: ['https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components/-/raw/master/doc/feed/feed-en.json'],
         },
@@ -119,4 +121,4 @@ export const environment = Object.freeze({
         maxCount: 3,
     },
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../../../src/environments/environment.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,2EAA2E;AAC3E,gEAAgE;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAGrE;;;;;GAKG;AACH,sCAAsC;AAEtC,MAAM,CAAC,MAAM,WAAW,GAAgB,MAAM,CAAC,MAAM,CAAc;IACjE,IAAI,EAAE,6BAA6B,EAAE,kCAAkC;IACvE,OAAO,EAAE,KAAK,EAAE,kCAAkC;IAElD,oEAAoE;IACpE,UAAU,EAAE,IAAI;IAEhB,2DAA2D;IAC3D,+BAA+B;IAE/B,OAAO,EAAE,GAAG;IACZ,aAAa,EAAE,IAAI;IACnB,oBAAoB,EAAE,MAAM;IAC5B,iBAAiB,EAAE,aAAa;IAChC,OAAO,EAAE,KAAK;IACd,aAAa,EAAE,IAAI;IAEnB,wBAAwB;IACxB,mBAAmB;IAEnB,sBAAsB;IACtB,YAAY,EAAE,KAAK;IAEnB,wBAAwB;IACxB,gBAAgB;IAEhB,cAAc,EAAE,OAAO;IAEvB,yBAAyB,EAAE,IAAI;IAE/B,WAAW,EAAE;QACX,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,IAAI;KACX;IAED,YAAY,EAAE;QACZ;YACE,IAAI,EAAE,WAAW;YACjB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,WAAW;YACjB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,cAAc;YACpB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,cAAc;YACpB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,cAAc;YACpB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,YAAY;YAClB,IAAI,EAAE,GAAG;SACV;QACD;YACE,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE,GAAG;SACV;QACD;YACE,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE,GAAG;SACV;QACD;YACE,IAAI,EAAE,iBAAiB;YACvB,IAAI,EAAE,GAAG;SACV;KACF;IACD,cAAc,EAAE,SAAS;IACzB,wBAAwB,EAAE,+DAA+D;IACzF,oBAAoB,EAAE,oDAAoD;IAC1E,wBAAwB,EAAE,qEAAqE;IAE/F,UAAU;IACV,OAAO,EAAE;QACP,WAAW,EAAE,CAAC,cAAc,CAAC,OAAO,EAAE,cAAc,CAAC,SAAS,EAAE,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,YAAY,CAAC;KACpH;IAED,QAAQ;IACR,SAAS,EAAE,qEAAqE;IAChF,cAAc,EAAE,8EAA8E;IAC9F,QAAQ,EAAE,IAAI,EAAE,8BAA8B;IAC9C,OAAO,EAAE,gGAAgG;IACzG,gBAAgB,EAAE,gGAAgG;IAClH,aAAa,EAAE,6GAA6G;IAE5H,cAAc;IACd,iBAAiB,EAAE;QACjB,mCAAmC;QACnC,QAAQ,EAAE,mBAAmB;QAC7B,QAAQ,EAAE,OAAO;KAClB;IAED,OAAO,EAAE;QACP,mBAAmB,EAAE,IAAI;QACzB,uBAAuB,EAAE,EAAE;KAC5B;IAED,YAAY,EAAE;QACZ,mBAAmB,EAAE,IAAI;QACzB,uBAAuB,EAAE,EAAE;KAC5B;IAED,IAAI,EAAE;QACJ,QAAQ,EAAE;YACR,EAAE,EAAE;gBACF,wGAAwG;gBACxG,yFAAyF;gBACzF,kFAAkF;aACnF;YAED,EAAE,EAAE,CAAC,wGAAwG,CAAC;SAC/G;QACD,gBAAgB,EAAE,IAAI;QACtB,cAAc,EAAE,CAAC,CAAC;QAClB,QAAQ,EAAE,CAAC;KACZ;CACF,CAAC,CAAC","sourcesContent":["// This file can be replaced during build by using the `fileReplacements` array.\n// `ng build ---prod` replaces `environment.ts` with `environment.prod.ts`.\n// The list of file replacements can be found in `angular.json`.\nimport { StorageDrivers } from '../app/shared/storage/storage.utils';\n\nimport { Environment } from './environment.class';\n/*\n * In development mode, to ignore zone related error stack frames such as\n * `zone.run`, `zoneDelegate.invokeTask` for easier debugging, you can\n * import the following file, but please comment it out in production mode\n * because it will have performance impact when throw error\n */\n//import 'zone.js/plugins/zone-error';\n\nexport const environment: Environment = Object.freeze(<Environment>{\n  name: '@sumaris-net/ngx-components', // overridden by ENVIRONMENT token\n  version: '1.0', // overridden by ENVIRONMENT token\n\n  // Do NOT set to false - because this value will be used by releases\n  production: true,\n\n  // Do NOT set - because this value will be used by releases\n  //externalEnvironmentUrl: null,\n\n  baseUrl: '/',\n  defaultLocale: 'fr',\n  defaultLatLongFormat: 'DDMM',\n  apolloFetchPolicy: 'cache-first',\n  useHash: false,\n  allowDarkMode: true,\n\n  //defaultRoute: '/home',\n  //enableMenu: true,\n\n  // FIXME: enable cache\n  persistCache: false,\n\n  // TODO: make this works\n  //offline: true,\n\n  peerMinVersion: '1.8.0',\n\n  enableSelectPeerByFeature: true,\n\n  defaultPeer: {\n    host: 'localhost',\n    port: 8081,\n  },\n\n  defaultPeers: [\n    {\n      host: 'localhost',\n      port: 8080,\n    },\n    {\n      host: 'localhost',\n      port: 8081,\n    },\n    {\n      host: '192.168.0.45',\n      port: 8080,\n    },\n    {\n      host: '192.168.0.24',\n      port: 8080,\n    },\n    {\n      host: '192.168.0.29',\n      port: 8080,\n    },\n    {\n      host: '192.168.0.107',\n      port: 8080,\n    },\n    {\n      host: 'sih.sfa.sc',\n      port: 443,\n    },\n    {\n      host: 'test.sumaris.net',\n      port: 443,\n    },\n    {\n      host: 'open.sumaris.net',\n      port: 443,\n    },\n    {\n      host: 'server.e-is.pro',\n      port: 443,\n    },\n  ],\n  defaultAppName: 'SUMARiS',\n  defaultAndroidInstallUrl: 'https://play.google.com/store/apps/details?id=net.sumaris.app',\n  defaultIOSInstallUrl: 'https://apps.apple.com/us/app/sumaris/id6736747523',\n  defaultDesktopInstallUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/releases',\n\n  // Storage\n  storage: {\n    driverOrder: [StorageDrivers.SQLLite, StorageDrivers.IndexedDB, StorageDrivers.WebSQL, StorageDrivers.LocalStorage],\n  },\n\n  // About\n  sourceUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components',\n  reportIssueUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components/-/issues',\n  forumUrl: null, //'https://forum.sumaris.net',\n  helpUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-doc/-/blob/master/user-manual/index_fr.md',\n  privacyPolicyUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/raw/master/doc/privacy_policy_fr.md',\n  termsOfUseUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/raw/master/doc/terms_of_use_fr.md?ref_type=heads',\n\n  // Development\n  defaultAuthValues: {\n    // Token auth (using Person.pubkey)\n    username: 'admin@sumaris.net',\n    password: 'admin',\n  },\n\n  account: {\n    enableListenChanges: true,\n    listenIntervalInSeconds: 60,\n  },\n\n  entityEditor: {\n    enableListenChanges: true,\n    listenIntervalInSeconds: 60,\n  },\n\n  feed: {\n    jsonFeed: {\n      fr: [\n        'https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components/-/raw/master/doc/feed/feed-fr.json',\n        //'https://raw.githubusercontent.com/duniter/cesium/master/doc/feed/1.1/feed-fr-FR.json',\n        //'https://raw.githubusercontent.com/duniter/cesium/master/doc/feed/feed-fr.json',\n      ],\n\n      en: ['https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components/-/raw/master/doc/feed/feed-en.json'],\n    },\n    maxContentLength: 1000,\n    maxAgeInMonths: -1,\n    maxCount: 3,\n  },\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../../../src/environments/environment.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,2EAA2E;AAC3E,gEAAgE;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAGrE;;;;;GAKG;AACH,sCAAsC;AAEtC,MAAM,CAAC,MAAM,WAAW,GAAgB,MAAM,CAAC,MAAM,CAAc;IACjE,IAAI,EAAE,6BAA6B,EAAE,kCAAkC;IACvE,OAAO,EAAE,KAAK,EAAE,kCAAkC;IAElD,oEAAoE;IACpE,UAAU,EAAE,IAAI;IAEhB,2DAA2D;IAC3D,+BAA+B;IAE/B,OAAO,EAAE,GAAG;IACZ,aAAa,EAAE,IAAI;IACnB,oBAAoB,EAAE,MAAM;IAC5B,iBAAiB,EAAE,aAAa;IAChC,OAAO,EAAE,KAAK;IACd,aAAa,EAAE,IAAI;IAEnB,wBAAwB;IACxB,mBAAmB;IAEnB,sBAAsB;IACtB,YAAY,EAAE,KAAK;IAEnB,wBAAwB;IACxB,gBAAgB;IAEhB,cAAc,EAAE,OAAO;IAEvB,yBAAyB,EAAE,IAAI;IAE/B,WAAW,EAAE;QACX,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,IAAI;KACX;IAED,YAAY,EAAE;QACZ;YACE,IAAI,EAAE,WAAW;YACjB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,WAAW;YACjB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,cAAc;YACpB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,cAAc;YACpB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,cAAc;YACpB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,IAAI;SACX;QACD;YACE,IAAI,EAAE,YAAY;YAClB,IAAI,EAAE,GAAG;SACV;QACD;YACE,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE,GAAG;SACV;QACD;YACE,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE,GAAG;SACV;QACD;YACE,IAAI,EAAE,iBAAiB;YACvB,IAAI,EAAE,GAAG;SACV;KACF;IACD,cAAc,EAAE,SAAS;IACzB,wBAAwB,EAAE,+DAA+D;IACzF,oBAAoB,EAAE,oDAAoD;IAC1E,wBAAwB,EAAE,qEAAqE;IAE/F,UAAU;IACV,OAAO,EAAE;QACP,WAAW,EAAE,CAAC,cAAc,CAAC,OAAO,EAAE,cAAc,CAAC,SAAS,EAAE,cAAc,CAAC,MAAM,EAAE,cAAc,CAAC,YAAY,CAAC;KACpH;IAED,QAAQ;IACR,SAAS,EAAE,qEAAqE;IAChF,cAAc,EAAE,8EAA8E;IAC9F,QAAQ,EAAE,IAAI,EAAE,8BAA8B;IAC9C,OAAO,EAAE,gGAAgG;IACzG,gBAAgB,EAAE,gGAAgG;IAClH,aAAa,EAAE,6GAA6G;IAE5H,cAAc;IACd,iBAAiB,EAAE;QACjB,mCAAmC;QACnC,QAAQ,EAAE,mBAAmB;QAC7B,QAAQ,EAAE,OAAO;KAClB;IAED,OAAO,EAAE;QACP,mBAAmB,EAAE,IAAI;QACzB,uBAAuB,EAAE,EAAE;KAC5B;IAED,YAAY,EAAE;QACZ,mBAAmB,EAAE,IAAI;QACzB,uBAAuB,EAAE,EAAE;KAC5B;IAED,IAAI,EAAE;QACJ,QAAQ,EAAE;YACR,EAAE,EAAE;gBACF,wGAAwG;gBACxG,gDAAgD;gBAChD,kFAAkF;gBAClF,+BAA+B;gBAC/B,yFAAyF;aAC1F;YAED,EAAE,EAAE,CAAC,wGAAwG,CAAC;SAC/G;QACD,gBAAgB,EAAE,IAAI;QACtB,cAAc,EAAE,CAAC,CAAC;QAClB,QAAQ,EAAE,CAAC;KACZ;CACF,CAAC,CAAC","sourcesContent":["// This file can be replaced during build by using the `fileReplacements` array.\n// `ng build ---prod` replaces `environment.ts` with `environment.prod.ts`.\n// The list of file replacements can be found in `angular.json`.\nimport { StorageDrivers } from '../app/shared/storage/storage.utils';\n\nimport { Environment } from './environment.class';\n/*\n * In development mode, to ignore zone related error stack frames such as\n * `zone.run`, `zoneDelegate.invokeTask` for easier debugging, you can\n * import the following file, but please comment it out in production mode\n * because it will have performance impact when throw error\n */\n//import 'zone.js/plugins/zone-error';\n\nexport const environment: Environment = Object.freeze(<Environment>{\n  name: '@sumaris-net/ngx-components', // overridden by ENVIRONMENT token\n  version: '1.0', // overridden by ENVIRONMENT token\n\n  // Do NOT set to false - because this value will be used by releases\n  production: true,\n\n  // Do NOT set - because this value will be used by releases\n  //externalEnvironmentUrl: null,\n\n  baseUrl: '/',\n  defaultLocale: 'fr',\n  defaultLatLongFormat: 'DDMM',\n  apolloFetchPolicy: 'cache-first',\n  useHash: false,\n  allowDarkMode: true,\n\n  //defaultRoute: '/home',\n  //enableMenu: true,\n\n  // FIXME: enable cache\n  persistCache: false,\n\n  // TODO: make this works\n  //offline: true,\n\n  peerMinVersion: '1.8.0',\n\n  enableSelectPeerByFeature: true,\n\n  defaultPeer: {\n    host: 'localhost',\n    port: 8081,\n  },\n\n  defaultPeers: [\n    {\n      host: 'localhost',\n      port: 8080,\n    },\n    {\n      host: 'localhost',\n      port: 8081,\n    },\n    {\n      host: '192.168.0.45',\n      port: 8080,\n    },\n    {\n      host: '192.168.0.24',\n      port: 8080,\n    },\n    {\n      host: '192.168.0.29',\n      port: 8080,\n    },\n    {\n      host: '192.168.0.107',\n      port: 8080,\n    },\n    {\n      host: 'sih.sfa.sc',\n      port: 443,\n    },\n    {\n      host: 'test.sumaris.net',\n      port: 443,\n    },\n    {\n      host: 'open.sumaris.net',\n      port: 443,\n    },\n    {\n      host: 'server.e-is.pro',\n      port: 443,\n    },\n  ],\n  defaultAppName: 'SUMARiS',\n  defaultAndroidInstallUrl: 'https://play.google.com/store/apps/details?id=net.sumaris.app',\n  defaultIOSInstallUrl: 'https://apps.apple.com/us/app/sumaris/id6736747523',\n  defaultDesktopInstallUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/releases',\n\n  // Storage\n  storage: {\n    driverOrder: [StorageDrivers.SQLLite, StorageDrivers.IndexedDB, StorageDrivers.WebSQL, StorageDrivers.LocalStorage],\n  },\n\n  // About\n  sourceUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components',\n  reportIssueUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components/-/issues',\n  forumUrl: null, //'https://forum.sumaris.net',\n  helpUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-doc/-/blob/master/user-manual/index_fr.md',\n  privacyPolicyUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/raw/master/doc/privacy_policy_fr.md',\n  termsOfUseUrl: 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/raw/master/doc/terms_of_use_fr.md?ref_type=heads',\n\n  // Development\n  defaultAuthValues: {\n    // Token auth (using Person.pubkey)\n    username: 'admin@sumaris.net',\n    password: 'admin',\n  },\n\n  account: {\n    enableListenChanges: true,\n    listenIntervalInSeconds: 60,\n  },\n\n  entityEditor: {\n    enableListenChanges: true,\n    listenIntervalInSeconds: 60,\n  },\n\n  feed: {\n    jsonFeed: {\n      fr: [\n        'https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components/-/raw/master/doc/feed/feed-fr.json',\n        // Example with JsonFeed version 1 (and not 1.1)\n        //'https://raw.githubusercontent.com/duniter/cesium/master/doc/feed/feed-fr.json',\n        // Example with discourse API :\n        //'https://raw.githubusercontent.com/duniter/cesium/master/doc/feed/1.1/feed-fr-FR.json',\n      ],\n\n      en: ['https://gitlab.ifremer.fr/sih-public/sumaris/ngx-sumaris-components/-/raw/master/doc/feed/feed-en.json'],\n    },\n    maxContentLength: 1000,\n    maxAgeInMonths: -1,\n    maxCount: 3,\n  },\n});\n"]}