@sumaris-net/ngx-components 18.14.0 → 18.14.2

package/esm2022/src/app/shared/version/versions.mjs

@@ -0,0 +1,81 @@
+const regexp = {
+    POSITIVE_INTEGER: /^\d+$/,
+    VERSION_PART_REGEXP: /^[0-9]+|alpha[0-9]+|beta[0-9]+|rc[0-9]+|[0-9]+-SNAPSHOT$/,
+};
+export class VersionUtils {
+    static compare = compareVersionNumbers;
+    static isCompatible = isVersionCompatible;
+    static isSame = isSameVersion;
+}
+/**
+ * Compare two software version numbers (e.g. 1.7.1)
+ * Returns:
+ *
+ *  0 if they're identical
+ *  negative if v1 < v2
+ *  positive if v1 > v2
+ *  Nan if they in the wrong format
+ *
+ *  E.g.:
+ *
+ *  assert(version_number_compare("1.7.1", "1.6.10") > 0);
+ *  assert(version_number_compare("1.7.1", "1.7.10") < 0);
+ *
+ *  "Unit tests": http://jsfiddle.net/ripper234/Xv9WL/28/
+ *
+ *  Taken from http://stackoverflow.com/a/6832721/11236
+ */
+export function compareVersionNumbers(v1, v2) {
+    const v1parts = v1.split('.');
+    const v2parts = v2.split('.');
+    // First, validate both numbers are true version numbers
+    if (!validateParts(v1parts) || !validateParts(v2parts)) {
+        return NaN;
+    }
+    for (let i = 0; i < v1parts.length; ++i) {
+        if (v2parts.length === i) {
+            return 1;
+        }
+        if (v1parts[i] === v2parts[i]) {
+            continue;
+        }
+        if (v1parts[i] > v2parts[i]) {
+            return 1;
+        }
+        return -1;
+    }
+    if (v1parts.length !== v2parts.length) {
+        return -1;
+    }
+    return 0;
+}
+function validateParts(parts) {
+    for (let i = 0; i < parts.length; i++) {
+        let isNumber = regexp.POSITIVE_INTEGER.test(parts[i]);
+        // First part MUST be an integer
+        if (i === 0 && !isNumber)
+            return false;
+        // If not integer, should be 'alpha', 'beta', etc.
+        if (!isNumber) {
+            if (!regexp.VERSION_PART_REGEXP.test(parts[i]))
+                return false;
+            // Remove '-SNAPSHOT', as it should never be in prod
+            parts[i] = parts[i].replace('-SNAPSHOT', '');
+            // Check again if numeric
+            isNumber = regexp.POSITIVE_INTEGER.test(parts[i]);
+        }
+        // Convert string to int (need by compare operators)
+        if (isNumber)
+            parts[i] = parseInt(parts[i]);
+    }
+    return true;
+}
+export function isVersionCompatible(minVersion, actualVersion) {
+    // DEV ONLY
+    //console.debug(`[http] Checking actual version {${actualVersion}} is compatible with min expected version {${minVersion}}`);
+    return compareVersionNumbers(minVersion, actualVersion) <= 0;
+}
+export function isSameVersion(v1, v2) {
+    return compareVersionNumbers(v1, v2) === 0;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/social/config/social.config.mjs

@@ -0,0 +1,9 @@
+export const SOCIAL_CONFIG_OPTIONS = Object.freeze({
+    ENABLE_NOTIFICATION_ICONS: {
+        key: 'sumaris.social.notification.icons.enable',
+        label: 'CONFIGURATION.OPTIONS.SOCIAL.ENABLE_NOTIFICATION_ICONS',
+        type: 'boolean',
+        defaultValue: false,
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29jaWFsLmNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc29jaWFsL2NvbmZpZy9zb2NpYWwuY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUM7SUFDakQseUJBQXlCLEVBQXVCO1FBQzlDLEdBQUcsRUFBRSwwQ0FBMEM7UUFDL0MsS0FBSyxFQUFFLHdEQUF3RDtRQUMvRCxJQUFJLEVBQUUsU0FBUztRQUNmLFlBQVksRUFBRSxLQUFLO0tBQ3BCO0NBQ0YsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9ybUZpZWxkRGVmaW5pdGlvbiB9IGZyb20gJy4uLy4uL3NoYXJlZC9mb3JtL2ZpZWxkLm1vZGVsJztcblxuZXhwb3J0IGNvbnN0IFNPQ0lBTF9DT05GSUdfT1BUSU9OUyA9IE9iamVjdC5mcmVlemUoe1xuICBFTkFCTEVfTk9USUZJQ0FUSU9OX0lDT05TOiA8Rm9ybUZpZWxkRGVmaW5pdGlvbj57XG4gICAga2V5OiAnc3VtYXJpcy5zb2NpYWwubm90aWZpY2F0aW9uLmljb25zLmVuYWJsZScsXG4gICAgbGFiZWw6ICdDT05GSUdVUkFUSU9OLk9QVElPTlMuU09DSUFMLkVOQUJMRV9OT1RJRklDQVRJT05fSUNPTlMnLFxuICAgIHR5cGU6ICdib29sZWFuJyxcbiAgICBkZWZhdWx0VmFsdWU6IGZhbHNlLFxuICB9LFxufSk7XG4iXX0=

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

@@ -0,0 +1,167 @@
+import { Inject, inject, Injectable, Optional } from '@angular/core';
+import { Promise } from '@rx-angular/cdk/zone-less/browser';
+import { DiscourseUtils } from './discourse.utils';
+import DiscourseAPI from 'discourse2';
+import { JsonFeedUtils } from '../feed.model';
+import { firstArrayValue, isEmptyArray, isNotEmptyArray, isNotNilOrBlank } from '../../../shared/functions';
+import { from, switchMap } from 'rxjs';
+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 class DiscourseFeedService extends StartableService {
+    settings;
+    environment;
+    discourseApis = new Map();
+    _logPrefix = '[discourse-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._debug = !environment.production;
+        if (this._debug)
+            console.debug('[discourse-feed-service] Creating service');
+        this._state.connect('locale', this.settings.locale$);
+        this._state.connect('feedUrls', this.locale$.pipe(filter(isNotNilOrBlank), map((locale) => (locale && environment.feed?.jsonFeed?.[locale]) ?? [])));
+    }
+    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)));
+        }
+        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,
+            closeApis: true,
+            ...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);
+                if (JsonFeedUtils.isJsonFeed(json)) {
+                    // Migrate old version
+                    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] : [];
+                }
+                // Get discourse
+                if (DiscourseUtils.isDiscourseObject(json)) {
+                    const api = this.getOrCreateDiscourseApi(url);
+                    return await DiscourseUtils.getFeedsByUrl(url, { ...opts, api });
+                }
+                return undefined;
+            }
+            catch (err) {
+                if (err?.status === 404) {
+                    console.error(`${this._logPrefix} Error while fetching feed at ${url}. 404 (Not found)`);
+                }
+                else {
+                    console.error(`${this._logPrefix} Error while fetching feed at ${url}`, err);
+                }
+                return Promise.resolve([]);
+            }
+        }));
+        if (opts?.closeApis !== false) {
+            this.closeApis();
+        }
+        const data = feeds.flat();
+        return { data, total: data.length };
+    }
+    getOrCreateDiscourseApi(url) {
+        const baseUrl = DiscourseUtils.getDiscourseBaseUrl(url);
+        let api = this.discourseApis.get(baseUrl);
+        if (!api) {
+            api = new DiscourseAPI(baseUrl);
+            this.discourseApis.set(baseUrl, api);
+        }
+        return api;
+    }
+    closeApis() {
+        this.discourseApis.clear();
+    }
+    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, closeApis: false, 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;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DiscourseFeedService, 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: DiscourseFeedService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DiscourseFeedService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.LocalSettingsService }, { type: i2.Environment, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discourse-feed.service.js","sourceRoot":"","sources":["../../../../../../../src/app/social/feed/discourse/discourse-feed.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, inject, Injectable, Optional } from '@angular/core';\n\nimport { Promise } from '@rx-angular/cdk/zone-less/browser';\nimport { DiscourseUtils } from './discourse.utils';\nimport DiscourseAPI from 'discourse2';\nimport { JsonFeed, JsonFeedUtils } from '../feed.model';\nimport { firstArrayValue, isEmptyArray, isNotEmptyArray, isNotNilOrBlank } from '../../../shared/functions';\nimport { from, Observable, switchMap } from 'rxjs';\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 { LoadResult } from '../../../shared/services/entity-service.class';\nimport { UrlUtils } from '../../../shared/file/url.utils';\nimport { IFeedService } from '../feed.service';\n\nexport interface DiscourseFeedServiceState {\n  locale: string;\n  feedUrls?: string[];\n}\n\n@Injectable({ providedIn: 'root' })\nexport class DiscourseFeedService extends StartableService<DiscourseFeedServiceState> implements IFeedService {\n  private discourseApis = new Map<string, DiscourseAPI>();\n  private _logPrefix = '[discourse-feed-service] ';\n\n  private _state = new RxState<DiscourseFeedServiceState>();\n  private 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  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._debug = !environment.production;\n    if (this._debug) console.debug('[discourse-feed-service] Creating service');\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\n  protected async ngOnStart(): Promise<DiscourseFeedServiceState> {\n    await this.settings.ready();\n    return {\n      locale: this.settings.locale,\n    };\n  }\n\n  watchAll(opts?: { maxAgeInMonths?: number; maxContentLength?: number }): Observable<LoadResult<JsonFeed>> {\n    if (!this.started) {\n      return from(this.start()).pipe(switchMap(() => this.watchAll(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      closeApis?: boolean;\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      closeApis?: boolean;\n      depth?: number;\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      closeApis: true,\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          if (JsonFeedUtils.isJsonFeed(json)) {\n            // Migrate old version\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          // Get discourse\n          if (DiscourseUtils.isDiscourseObject(json)) {\n            const api = this.getOrCreateDiscourseApi(url);\n            return await DiscourseUtils.getFeedsByUrl(url, { ...opts, api });\n          }\n\n          return undefined;\n        } catch (err) {\n          if (err?.status === 404) {\n            console.error(`${this._logPrefix} Error while fetching feed at ${url}. 404 (Not found)`);\n          } else {\n            console.error(`${this._logPrefix} Error while fetching feed at ${url}`, err);\n          }\n          return Promise.resolve([]);\n        }\n      })\n    );\n\n    if (opts?.closeApis !== false) {\n      this.closeApis();\n    }\n\n    const data = feeds.flat();\n\n    return { data, total: data.length };\n  }\n\n  protected getOrCreateDiscourseApi(url: string) {\n    const baseUrl = DiscourseUtils.getDiscourseBaseUrl(url);\n    let api = this.discourseApis.get(baseUrl);\n    if (!api) {\n      api = new DiscourseAPI(baseUrl);\n      this.discourseApis.set(baseUrl, api);\n    }\n    return api;\n  }\n\n  protected closeApis() {\n    this.discourseApis.clear();\n  }\n\n  protected async resolveFeedItems(json: JsonFeed, opts?: { maxContentLength?: number; depth?: number }): 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, closeApis: false, 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"]}

package/esm2022/src/app/social/feed/discourse/discourse.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzY291cnNlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9zb2NpYWwvZmVlZC9kaXNjb3Vyc2UvZGlzY291cnNlLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IG9wZXJhdGlvbnMgfSBmcm9tICdkaXNjb3Vyc2UyL2VzbS9zY2hlbWEnO1xuXG5leHBvcnQgdHlwZSBEaXNjb3Vyc2VDYXRlZ29yeSA9IG9wZXJhdGlvbnNbJ2xpc3RDYXRlZ29yeVRvcGljcyddWydyZXNwb25zZXMnXVsnMjAwJ11bJ2NvbnRlbnQnXVsnYXBwbGljYXRpb24vanNvbiddO1xuZXhwb3J0IHR5cGUgRGlzY291cnNlQ2F0ZWdvcnlUb3BpYyA9IERpc2NvdXJzZUNhdGVnb3J5Wyd0b3BpY19saXN0J11bJ3RvcGljcyddWzBdO1xuZXhwb3J0IHR5cGUgRGlzY291cnNlVG9waWMgPSBvcGVyYXRpb25zWydnZXRUb3BpYyddWydyZXNwb25zZXMnXVsnMjAwJ11bJ2NvbnRlbnQnXVsnYXBwbGljYXRpb24vanNvbiddO1xuXG5leHBvcnQgdHlwZSBEaXNjb3Vyc2VQb3N0ID0gb3BlcmF0aW9uc1snZ2V0VG9waWMnXVsncmVzcG9uc2VzJ11bJzIwMCddWydjb250ZW50J11bJ2FwcGxpY2F0aW9uL2pzb24nXVsncG9zdF9zdHJlYW0nXVsncG9zdHMnXVswXSAmIHtcbiAgcG9zdF91cmw/OiBzdHJpbmc7XG59O1xuIl19

package/esm2022/src/app/social/feed/discourse/discourse.utils.mjs

@@ -0,0 +1,168 @@
+import DiscourseAPI from 'discourse2';
+import { Promise } from '@rx-angular/cdk/zone-less/browser';
+import { JsonFeedUtils } from '../feed.model';
+import { UrlUtils } from '../../../shared/file/url.utils';
+import { isEmptyArray, isNotNil } from '../../../shared/functions';
+import { DateUtils } from '../../../shared/dates';
+export class DiscourseUtils {
+    static _logPrefix = '[discourse-utils]';
+    static removeJsonExtension = JsonFeedUtils.removeJsonExtension;
+    static isDiscourseObject(json) {
+        return this.isDiscourseTopic(json) || this.isDiscourseCategory(json);
+    }
+    static isDiscourseTopic(json) {
+        return (json && !!json.post_stream?.posts && json.fancy_title && json.slug && json.details?.created_by && true) || false;
+    }
+    static isDiscourseCategory(json) {
+        return (json && json.topic_list?.topics && json.posters && true) || false;
+    }
+    static getDiscourseBaseUrl(url) {
+        return UrlUtils.getRootUrl(url);
+    }
+    static isDiscourseCategoryUrl(url) {
+        const baseUrl = this.getDiscourseBaseUrl(url);
+        return baseUrl && url.substring(baseUrl.length).match(/^\/c\//);
+    }
+    static extractCategoryIdFromUrl(url) {
+        const match = this.removeJsonExtension(url).match(/\/(\d+)$/);
+        return match ? parseInt(match[1], 10) : null;
+    }
+    static extractCategorySlugFromUrl(url) {
+        const match = this.removeJsonExtension(url).match(/\/c\/([\w/-]+)\/\d+$/);
+        return match ? match[1] : null;
+    }
+    static extractTopicIdFromUrl(url) {
+        const match = url.match(/\/(\d+)(?:$|\/)/) || url.match(/\/(\d+)\.json$/);
+        return match ? parseInt(match[1], 10) : null;
+    }
+    static getLanguageFromTitle(title) {
+        if (!title)
+            return '';
+        const match = title.match('\\s\\(([a-z]{2}(?:-[A-Z]{2})?)\\)$');
+        return match && match[1];
+    }
+    static async getFeedsByUrl(url, opts) {
+        try {
+            // Check a category
+            if (DiscourseUtils.isDiscourseCategoryUrl(url)) {
+                console.debug(`${this._logPrefix}Detected a Discourse category at: ${url}`);
+                return this.getFeedsByCategoryUrl(url, opts);
+            }
+            // Or a topic
+            else {
+                const post = await this.getFeedByTopicUrl(url, opts);
+                return post ? [post] : [];
+            }
+        }
+        catch (err) {
+            console.error(`${this._logPrefix}`, err);
+            return [];
+        }
+    }
+    static async getFeedsByCategoryUrl(url, opts) {
+        const categoryId = this.extractCategoryIdFromUrl(url);
+        const categorySlug = this.extractCategorySlugFromUrl(url);
+        const baseUrl = this.getDiscourseBaseUrl(url);
+        const api = opts?.api ?? new DiscourseAPI(baseUrl);
+        const category = await api.listCategoryTopics({ id: categoryId, slug: categorySlug });
+        const topics = (category?.topic_list?.topics || []).filter((topic) => {
+            const topicLocale = this.getLanguageFromTitle(topic.fancy_title);
+            return (topic.pinned &&
+                topic.visible &&
+                // Keep same locale, if exists
+                (!topicLocale || !opts?.locale || topicLocale === opts.locale));
+        });
+        const posts = (await Promise.all(topics.map(async (t) => {
+            const topic = await api.getTopic({ id: t.id.toString() });
+            // Ignore 'About' topics
+            if (topic.tags.includes('about-category'))
+                return undefined;
+            const posts = this.filterRecentPosts(topic.post_stream.posts, opts);
+            if (isEmptyArray(posts))
+                return undefined;
+            return this.toFeed(posts, topic, url, opts);
+        }))).filter(isNotNil);
+        if (isEmptyArray(posts)) {
+            console.warn(`${this._logPrefix}No recent post found on category #${categoryId}`);
+        }
+        return posts;
+    }
+    static async getFeedByTopicUrl(url, opts) {
+        const topicId = this.extractTopicIdFromUrl(url);
+        if (!topicId) {
+            console.error(`${this._logPrefix}Invalid URL`);
+            return undefined;
+        }
+        const api = opts?.api ?? new DiscourseAPI(this.getDiscourseBaseUrl(url));
+        const topic = await api.getTopic({ id: topicId.toString() });
+        // Ignore about category
+        if (topic.tags?.includes('about-category'))
+            return undefined;
+        const posts = this.filterRecentPosts(topic.post_stream.posts, opts);
+        if (isEmptyArray(posts)) {
+            console.warn(`${this._logPrefix}No recent posts found in topic #${topicId}`);
+            return undefined;
+        }
+        return this.toFeed(posts, topic, url, opts);
+    }
+    static filterRecentPosts(posts, opts) {
+        const maxAgeInMonths = opts?.maxAgeInMonths ?? JsonFeedUtils.DEFAULT_MAX_POST_AGE_IN_MONTHS;
+        if (maxAgeInMonths <= 0)
+            return posts; // Accept all
+        const minDate = maxAgeInMonths > 0 ? DateUtils.moment().subtract(maxAgeInMonths, 'month').startOf('day').utc() : undefined;
+        return (posts || []).filter((post) => post && DateUtils.moment(post.created_at).isSameOrAfter(minDate));
+    }
+    static toFeed(posts, topic, url, opts) {
+        const baseUrl = this.getDiscourseBaseUrl(url);
+        const title = this.cleanTitle(topic.fancy_title ?? topic.title);
+        const items = (posts || []).map((post) => this.toFeedItem(post, topic, url, opts));
+        const firstItem = items?.[0];
+        if (firstItem)
+            firstItem.title = title;
+        const authorName = topic?.details?.created_by && (topic.details.created_by.name || topic.details.created_by.username);
+        const authorAvatar = baseUrl + topic.details.created_by.avatar_template.replace('{size}', '48');
+        return {
+            version: JsonFeedUtils.VERSION_1_1,
+            feed_url: url,
+            title: this.cleanTitle(topic.fancy_title),
+            expired: topic.archived,
+            authors: [
+                {
+                    name: authorName,
+                    avatar: authorAvatar,
+                },
+            ],
+            items,
+            tag_template: baseUrl + '/tag/{tag}',
+        };
+    }
+    static toFeedItem(post, topic, url, opts) {
+        const baseUrl = this.getDiscourseBaseUrl(url);
+        url = post.post_url ? baseUrl + post.post_url : url;
+        const id = post.post_url ? baseUrl + post.post_url : post.id;
+        const html = JsonFeedUtils.truncateHtml(post.cooked, opts);
+        const truncated = html?.length !== post.cooked?.length;
+        const authorName = post.name || post.username;
+        const authorAvatar = baseUrl + (post.avatar_template.replace('{size}', '48') ?? topic.details.last_poster.avatar_template.replace('{size}', '48'));
+        return {
+            id,
+            url,
+            authors: [
+                {
+                    name: authorName,
+                    avatar: authorAvatar,
+                },
+            ],
+            content_html: html,
+            date_published: post.created_at,
+            tags: topic.tags,
+            truncated,
+        };
+    }
+    static cleanTitle(title) {
+        if (!title)
+            return undefined;
+        return title.replace(/\s\([a-z]{2}(:?-[A-Z]{2})?\)$/, '');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"discourse.utils.js","sourceRoot":"","sources":["../../../../../../../src/app/social/feed/discourse/discourse.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import DiscourseAPI from 'discourse2';\nimport { Promise } from '@rx-angular/cdk/zone-less/browser';\nimport { JsonFeed, JsonFeedItem, JsonFeedUtils } from '../feed.model';\nimport { DiscourseCategory, DiscourseCategoryTopic, DiscoursePost, DiscourseTopic } from './discourse.model';\nimport { UrlUtils } from '../../../shared/file/url.utils';\nimport { isEmptyArray, isNotNil } from '../../../shared/functions';\nimport { DateUtils } from '../../../shared/dates';\n\nexport abstract class DiscourseUtils {\n  static _logPrefix = '[discourse-utils]';\n\n  static removeJsonExtension = JsonFeedUtils.removeJsonExtension;\n\n  static isDiscourseObject(json: any): json is DiscourseTopic | DiscourseCategory {\n    return this.isDiscourseTopic(json) || this.isDiscourseCategory(json);\n  }\n\n  static isDiscourseTopic(json: any | Partial<DiscourseTopic>): json is DiscourseTopic {\n    return (json && !!json.post_stream?.posts && json.fancy_title && json.slug && json.details?.created_by && true) || false;\n  }\n\n  static isDiscourseCategory(json: any | Partial<DiscourseCategory>): json is DiscourseCategory {\n    return (json && json.topic_list?.topics && json.posters && true) || false;\n  }\n\n  static getDiscourseBaseUrl(url: string) {\n    return UrlUtils.getRootUrl(url);\n  }\n\n  static isDiscourseCategoryUrl(url: string) {\n    const baseUrl = this.getDiscourseBaseUrl(url);\n    return baseUrl && url.substring(baseUrl.length).match(/^\\/c\\//);\n  }\n\n  static extractCategoryIdFromUrl(url: string) {\n    const match = this.removeJsonExtension(url).match(/\\/(\\d+)$/);\n    return match ? parseInt(match[1], 10) : null;\n  }\n\n  static extractCategorySlugFromUrl(url: string) {\n    const match = this.removeJsonExtension(url).match(/\\/c\\/([\\w/-]+)\\/\\d+$/);\n    return match ? match[1] : null;\n  }\n\n  static extractTopicIdFromUrl(url: string) {\n    const match = url.match(/\\/(\\d+)(?:$|\\/)/) || url.match(/\\/(\\d+)\\.json$/);\n    return match ? parseInt(match[1], 10) : null;\n  }\n\n  static getLanguageFromTitle(title: string) {\n    if (!title) return '';\n\n    const match = title.match('\\\\s\\\\(([a-z]{2}(?:-[A-Z]{2})?)\\\\)$');\n    return match && match[1];\n  }\n\n  static async getFeedsByUrl(\n    url: string,\n    opts?: { api?: DiscourseAPI; locale?: string; maxAgeInMonths?: number; maxContentLength?: number }\n  ): Promise<JsonFeed[]> {\n    try {\n      // Check a category\n      if (DiscourseUtils.isDiscourseCategoryUrl(url)) {\n        console.debug(`${this._logPrefix}Detected a Discourse category at: ${url}`);\n        return this.getFeedsByCategoryUrl(url, opts);\n      }\n\n      // Or a topic\n      else {\n        const post = await this.getFeedByTopicUrl(url, opts);\n        return post ? [post] : [];\n      }\n    } catch (err) {\n      console.error(`${this._logPrefix}`, err);\n      return [];\n    }\n  }\n\n  static async getFeedsByCategoryUrl(\n    url: string,\n    opts?: { api?: DiscourseAPI; locale?: string; maxAgeInMonths?: number; maxContentLength?: number }\n  ): Promise<JsonFeed[]> {\n    const categoryId = this.extractCategoryIdFromUrl(url);\n    const categorySlug = this.extractCategorySlugFromUrl(url);\n    const baseUrl = this.getDiscourseBaseUrl(url);\n    const api = opts?.api ?? new DiscourseAPI(baseUrl);\n    const category: DiscourseCategory = await api.listCategoryTopics({ id: categoryId, slug: categorySlug });\n\n    const topics = (category?.topic_list?.topics || []).filter((topic: DiscourseCategoryTopic) => {\n      const topicLocale = this.getLanguageFromTitle(topic.fancy_title);\n      return (\n        topic.pinned &&\n        topic.visible &&\n        // Keep same locale, if exists\n        (!topicLocale || !opts?.locale || topicLocale === opts.locale)\n      );\n    });\n\n    const posts = (\n      await Promise.all(\n        topics.map(async (t) => {\n          const topic: DiscourseTopic = await api.getTopic({ id: t.id.toString() });\n\n          // Ignore 'About' topics\n          if (topic.tags.includes('about-category')) return undefined;\n\n          const posts = this.filterRecentPosts(topic.post_stream.posts, opts);\n          if (isEmptyArray(posts)) return undefined;\n          return this.toFeed(posts, topic, url, opts);\n        })\n      )\n    ).filter(isNotNil);\n\n    if (isEmptyArray(posts)) {\n      console.warn(`${this._logPrefix}No recent post found on category #${categoryId}`);\n    }\n\n    return posts;\n  }\n\n  static async getFeedByTopicUrl(\n    url: string,\n    opts?: { locale?: string; maxAgeInMonths?: number; maxContentLength?: number;\n      // Internal usage\n      api?: DiscourseAPI;\n    }\n  ): Promise<JsonFeed> {\n    const topicId = this.extractTopicIdFromUrl(url);\n    if (!topicId) {\n      console.error(`${this._logPrefix}Invalid URL`);\n      return undefined;\n    }\n    const api = opts?.api ?? new DiscourseAPI(this.getDiscourseBaseUrl(url));\n    const topic = await api.getTopic({ id: topicId.toString() });\n\n    // Ignore about category\n    if (topic.tags?.includes('about-category')) return undefined;\n\n    const posts = this.filterRecentPosts(topic.post_stream.posts, opts);\n\n    if (isEmptyArray(posts)) {\n      console.warn(`${this._logPrefix}No recent posts found in topic #${topicId}`);\n      return undefined;\n    }\n\n    return this.toFeed(posts, topic, url, opts);\n  }\n\n  static filterRecentPosts(posts: DiscoursePost[], opts?: { maxAgeInMonths?: number }): DiscoursePost[] {\n    const maxAgeInMonths = opts?.maxAgeInMonths ?? JsonFeedUtils.DEFAULT_MAX_POST_AGE_IN_MONTHS;\n    if (maxAgeInMonths <= 0) return posts; // Accept all\n\n    const minDate = maxAgeInMonths > 0 ? DateUtils.moment().subtract(maxAgeInMonths, 'month').startOf('day').utc() : undefined;\n    return (posts || []).filter((post) => post && DateUtils.moment(post.created_at).isSameOrAfter(minDate));\n  }\n\n  static toFeed(posts: DiscoursePost[], topic: DiscourseTopic, url: string, opts?: { maxContentLength?: number }): JsonFeed {\n    const baseUrl = this.getDiscourseBaseUrl(url);\n    const title = this.cleanTitle(topic.fancy_title ?? topic.title);\n    const items = (posts || []).map((post) => this.toFeedItem(post, topic, url, opts));\n    const firstItem = items?.[0];\n    if (firstItem) firstItem.title = title;\n    const authorName = topic?.details?.created_by && (topic.details.created_by.name || topic.details.created_by.username);\n    const authorAvatar = baseUrl + topic.details.created_by.avatar_template.replace('{size}', '48');\n    return <JsonFeed>{\n      version: JsonFeedUtils.VERSION_1_1,\n      feed_url: url,\n      title: this.cleanTitle(topic.fancy_title),\n      expired: topic.archived,\n      authors: [\n        {\n          name: authorName,\n          avatar: authorAvatar,\n        },\n      ],\n      items,\n      tag_template: baseUrl + '/tag/{tag}',\n    };\n  }\n\n  static toFeedItem(post: DiscoursePost, topic: DiscourseTopic, url: string, opts?: { maxContentLength?: number }): JsonFeedItem {\n    const baseUrl = this.getDiscourseBaseUrl(url);\n    url = post.post_url ? baseUrl + post.post_url : url;\n    const id = post.post_url ? baseUrl + post.post_url : post.id;\n    const html = JsonFeedUtils.truncateHtml(post.cooked, opts);\n    const truncated = html?.length !== post.cooked?.length;\n    const authorName = post.name || post.username;\n    const authorAvatar =\n      baseUrl + (post.avatar_template.replace('{size}', '48') ?? topic.details.last_poster.avatar_template.replace('{size}', '48'));\n    return <JsonFeedItem>{\n      id,\n      url,\n      authors: [\n        {\n          name: authorName,\n          avatar: authorAvatar,\n        },\n      ],\n      content_html: html,\n      date_published: post.created_at,\n      tags: topic.tags,\n      truncated,\n    };\n  }\n\n  static cleanTitle(title: string) {\n    if (!title) return undefined;\n    return title.replace(/\\s\\([a-z]{2}(:?-[A-Z]{2})?\\)$/, '');\n  }\n}\n"]}