geonetwork-ui 2.1.0-initial

package/esm2022/libs/util/i18n/src/lib/testing/test.translate.module.mjs

@@ -0,0 +1,109 @@
+import { NgModule } from '@angular/core';
+import { FakeMissingTranslationHandler, TranslateDefaultParser, TranslateFakeCompiler, TranslateModule, TranslateService, } from '@ngx-translate/core';
+import { TestTranslateLoader } from './test.translate.loader';
+import * as i0 from "@angular/core";
+// IMPORTANT:
+// This was copy-pasted from https://github.com/mwootendev/ngx-translate-plugins/blob/7c6c73c7d16c9519a7bafff939d29fd8ea5e574a/projects/testing/src/lib/testing.module.ts
+// because the original package was expecting rxjs 7+ as a peer dep and that was conflicting with many other dependencies
+// FIXME: when rxjs 7 can be used in the project, remove this and do `npm install ngx-translate-testing --save-dev`
+/**
+ * The TranslateTestingModule provides the {TranslateModule} as well as a
+ * {TranslateService} configured to return translations specific for the
+ * test environment.
+ *
+ * @export
+ */
+export class TranslateTestingModule {
+    constructor() {
+        this._translations = {};
+    }
+    static withTranslations(languageOrTranslations, translations) {
+        const translateTestingModule = new TranslateTestingModule();
+        if (typeof languageOrTranslations === 'string') {
+            return translateTestingModule.withTranslations(languageOrTranslations, translations);
+        }
+        return translateTestingModule.withTranslations(languageOrTranslations);
+    }
+    get ngModule() {
+        return TranslateTestingModule;
+    }
+    get providers() {
+        const translateService = new TranslateService(null, new TestTranslateLoader(this._translations), this._compiler || new TranslateFakeCompiler(), new TranslateDefaultParser(), new FakeMissingTranslationHandler(), true, true, false, this._defaultLanguage);
+        return [
+            {
+                provide: TranslateService,
+                useValue: translateService,
+            },
+        ];
+    }
+    withTranslations(languageOrTranslations, translations) {
+        if (typeof languageOrTranslations === 'string' && translations) {
+            this.addTranslations(languageOrTranslations, translations);
+            this._defaultLanguage = languageOrTranslations;
+        }
+        else if (languageOrTranslations) {
+            Object.keys(languageOrTranslations).forEach((language) => this.addTranslations(language, languageOrTranslations[language]));
+        }
+        return this;
+    }
+    /**
+     * Updates the {TranslationTestingModule} to provide a {TranslateService} that will
+     * use the provided {TranslateCompiler} to translate the test translations.
+     *
+     * @example
+     *
+     * TranslateTestingModule.withTranslations('en', {people: '{gender, select, male{He is} female{She is} other{They are}} {how})'})
+     *   .withCompiler(new TranslateMessageFormatCompiler());
+     *
+     * @param compiler the compiler to use to compile the test translations.
+     * @returns the instance that can be used to chain additional configuration.
+     * @memberof TranslateTestingModule
+     */
+    withCompiler(compiler) {
+        this._compiler = compiler;
+        return this;
+    }
+    /**
+     * Updates the {TranslateTestingModule} to use the provided language as the default language.
+     * By default, the default language will be set to the first language provided.
+     *
+     * @example
+     *
+     * TranslateTestingModule.withTranslations('es', SPANISH_TRANSLATIONS)
+     *   .withTranslations('en', ENGLISH_TRANSLATIONS)
+     *   .withDefaultLanguage('en');
+     *
+     * @param language the new default language for translations.
+     * @returns the instance that can be used to chain additional configuration.
+     * @memberof TranslateTestingModule
+     */
+    withDefaultLanguage(language) {
+        this._defaultLanguage = language || this._defaultLanguage;
+        return this;
+    }
+    addTranslations(language, translations) {
+        if (!this._defaultLanguage) {
+            this._defaultLanguage = language;
+        }
+        if (this._translations[language]) {
+            this._translations[language] = {
+                ...this._translations[language],
+                ...translations,
+            };
+        }
+        else {
+            this._translations[language] = translations;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TranslateTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: TranslateTestingModule, imports: [TranslateModule], exports: [TranslateModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TranslateTestingModule, imports: [TranslateModule, TranslateModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: TranslateTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [TranslateModule],
+                    exports: [TranslateModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.translate.module.js","sourceRoot":"","sources":["../../../../../../../../libs/util/i18n/src/lib/testing/test.translate.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { ModuleWithProviders, NgModule } from '@angular/core'\nimport {\n  FakeMissingTranslationHandler,\n  TranslateDefaultParser,\n  TranslateFakeCompiler,\n  TranslateModule,\n  TranslateService,\n  TranslateCompiler,\n} from '@ngx-translate/core'\nimport { TestTranslateLoader } from './test.translate.loader'\nimport { LanguageTranslations, Translations } from './translations.model'\n\n// IMPORTANT:\n// This was copy-pasted from https://github.com/mwootendev/ngx-translate-plugins/blob/7c6c73c7d16c9519a7bafff939d29fd8ea5e574a/projects/testing/src/lib/testing.module.ts\n// because the original package was expecting rxjs 7+ as a peer dep and that was conflicting with many other dependencies\n// FIXME: when rxjs 7 can be used in the project, remove this and do `npm install ngx-translate-testing --save-dev`\n\n/**\n * The TranslateTestingModule provides the {TranslateModule} as well as a\n * {TranslateService} configured to return translations specific for the\n * test environment.\n *\n * @export\n */\n@NgModule({\n  imports: [TranslateModule],\n  exports: [TranslateModule],\n})\nexport class TranslateTestingModule\n  implements ModuleWithProviders<TranslateTestingModule>\n{\n  private _translations: Translations = {}\n\n  private _defaultLanguage: string\n\n  private _compiler: TranslateCompiler\n\n  /**\n   * Creates a new instance of the {TranslateTestingModule} with translations for the specified language.\n   *\n   * @example\n   *\n   * const ENGLISH_TRANSLATIONS = { greeting: 'Hello' };\n   * const translateModule = TranslateTestingModule.withTranslations('en', ENGLISH_TRANSLATIONS);\n   *\n   * @example\n   *\n   * TranslateTestingModule.withTranslations('en', require('../../assets/i18n/en.json'));\n   *\n   * @static\n   * @param {string} language the language for the translations.\n   * @param {Translations} translations the translations to be used in the tests.\n   * @returns the new instance that can be used to chain additional configuration.\n   * @memberof TranslateTestingModule\n   */\n  public static withTranslations(\n    language: string,\n    translations: LanguageTranslations\n  ): TranslateTestingModule\n\n  /**\n   * Creates a new instance of the {TranslateTestingModule} with the provided translations.\n   *\n   * @example\n   *\n   * const TRANSLATIONS = { en: { greeting: 'Hello' }, es: { greeting: 'Hola' } };\n   * const translateModule = TranslateTestingModule.withTranslations(TRANSLATIONS);\n   *\n   * @example\n   *\n   * TranslateTestingModule.withTranslations(require('./test.i18n.json'));\n   *\n   * @static\n   * @param {Translations} the language translations the translations to be used in the tests.\n   * @returns the new instance that can be used to chain additional configuration.\n   * @memberof TranslateTestingModule\n   */\n  public static withTranslations(\n    translations: Translations\n  ): TranslateTestingModule\n\n  public static withTranslations(\n    languageOrTranslations: string | Translations,\n    translations?: LanguageTranslations\n  ): TranslateTestingModule {\n    const translateTestingModule = new TranslateTestingModule()\n\n    if (typeof languageOrTranslations === 'string') {\n      return translateTestingModule.withTranslations(\n        <string>languageOrTranslations,\n        translations\n      )\n    }\n\n    return translateTestingModule.withTranslations(languageOrTranslations)\n  }\n\n  public get ngModule() {\n    return TranslateTestingModule\n  }\n\n  public get providers() {\n    const translateService = new TranslateService(\n      null,\n      new TestTranslateLoader(this._translations),\n      this._compiler || new TranslateFakeCompiler(),\n      new TranslateDefaultParser(),\n      new FakeMissingTranslationHandler(),\n      true,\n      true,\n      false,\n      this._defaultLanguage\n    )\n\n    return [\n      {\n        provide: TranslateService,\n        useValue: translateService,\n      },\n    ]\n  }\n\n  /**\n   * Updates the {TranslateTestingModule} instance with additional translations. The\n   * translations will be shallowly merged with any existing translations.\n   *\n   * @example\n   *\n   * const ENGLISH_TRANSLATIONS = { en: { greeting: 'Hello' } };\n   * const SPANISH_TRANSLATIONS = { en: { greeting: 'Hola' } };\n   * const translateModule = TranslateTestingModule.withTranslations(ENGLISH_TRANSLATIONS)\n   *   .withTranslations(SPANISH_TRANSLATIONS);\n   *\n   * @param {Translations} translations the additional translations to add to the testing service.\n   * @returns the instance that can be used to chain additional configuration.\n   * @memberof TranslateTestingModule\n   */\n  public withTranslations(translations: Translations): TranslateTestingModule\n\n  /**\n   * Updates the {TranslateTestingModule} instance with additional translations for a\n   * specified language. The translations will be shallowly merged with any existing translations.\n   *\n   * @example\n   *\n   * const ENGLISH_TRANSLATIONS = { greeting: 'Hello' };\n   * const SPANISH_TRANSLATIONS = { greeting: 'Hola' };\n   * const translateModule = TranslateTestingModule.withTranslations('en', ENGLISH_TRANSLATIONS)\n   *   .withTranslations('es', SPANISH_TRANSLATIONS);\n   *\n   * @example\n   *\n   * TranslateTestingModule.withTranslations('en', require('../../assets/i18n/en.json'))\n   *   .withTranslations('es', require('../../assets/i18n/es.json'));\n   *\n   * @param {string} language the language for which the new translations are being added.\n   * @param {LanguageTranslations} translations the translations for the specified language.\n   * @returns the instance that can be used to chain additional configuration.\n   * @memberof TranslateTestingModule\n   */\n  public withTranslations(\n    language: string,\n    translations: LanguageTranslations\n  ): TranslateTestingModule\n\n  public withTranslations(\n    languageOrTranslations: string | Translations,\n    translations?: LanguageTranslations\n  ): TranslateTestingModule {\n    if (typeof languageOrTranslations === 'string' && translations) {\n      this.addTranslations(languageOrTranslations, translations)\n      this._defaultLanguage = languageOrTranslations\n    } else if (languageOrTranslations) {\n      Object.keys(languageOrTranslations).forEach((language) =>\n        this.addTranslations(language, languageOrTranslations[language])\n      )\n    }\n    return this\n  }\n\n  /**\n   * Updates the {TranslationTestingModule} to provide a {TranslateService} that will\n   * use the provided {TranslateCompiler} to translate the test translations.\n   *\n   * @example\n   *\n   * TranslateTestingModule.withTranslations('en', {people: '{gender, select, male{He is} female{She is} other{They are}} {how})'})\n   *   .withCompiler(new TranslateMessageFormatCompiler());\n   *\n   * @param compiler the compiler to use to compile the test translations.\n   * @returns the instance that can be used to chain additional configuration.\n   * @memberof TranslateTestingModule\n   */\n  public withCompiler(compiler: TranslateCompiler): TranslateTestingModule {\n    this._compiler = compiler\n    return this\n  }\n\n  /**\n   * Updates the {TranslateTestingModule} to use the provided language as the default language.\n   * By default, the default language will be set to the first language provided.\n   *\n   * @example\n   *\n   * TranslateTestingModule.withTranslations('es', SPANISH_TRANSLATIONS)\n   *   .withTranslations('en', ENGLISH_TRANSLATIONS)\n   *   .withDefaultLanguage('en');\n   *\n   * @param language the new default language for translations.\n   * @returns the instance that can be used to chain additional configuration.\n   * @memberof TranslateTestingModule\n   */\n  public withDefaultLanguage(language: string): TranslateTestingModule {\n    this._defaultLanguage = language || this._defaultLanguage\n    return this\n  }\n\n  private addTranslations(\n    language: string,\n    translations: LanguageTranslations\n  ) {\n    if (!this._defaultLanguage) {\n      this._defaultLanguage = language\n    }\n\n    if (this._translations[language]) {\n      this._translations[language] = {\n        ...this._translations[language],\n        ...translations,\n      }\n    } else {\n      this._translations[language] = translations\n    }\n  }\n}\n"]}

package/esm2022/libs/util/i18n/src/lib/testing/translations.model.mjs

@@ -0,0 +1,6 @@
+// IMPORTANT:
+// This was copy-pasted from https://github.com/mwootendev/ngx-translate-plugins/blob/7c6c73c7d16c9519a7bafff939d29fd8ea5e574a/projects/testing/src/lib/translations.model.ts
+// because the original package was expecting rxjs 7+ as a peer dep and that was conflicting with many other dependencies
+// FIXME: when rxjs 7 can be used in the project, remove this and do `npm install ngx-translate-testing --save-dev`
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRpb25zLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy91dGlsL2kxOG4vc3JjL2xpYi90ZXN0aW5nL3RyYW5zbGF0aW9ucy5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxhQUFhO0FBQ2IsNktBQTZLO0FBQzdLLHlIQUF5SDtBQUN6SCxtSEFBbUgiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBJTVBPUlRBTlQ6XG4vLyBUaGlzIHdhcyBjb3B5LXBhc3RlZCBmcm9tIGh0dHBzOi8vZ2l0aHViLmNvbS9td29vdGVuZGV2L25neC10cmFuc2xhdGUtcGx1Z2lucy9ibG9iLzdjNmM3M2M3ZDE2Yzk1MTlhN2JhZmZmOTM5ZDI5ZmQ4ZWE1ZTU3NGEvcHJvamVjdHMvdGVzdGluZy9zcmMvbGliL3RyYW5zbGF0aW9ucy5tb2RlbC50c1xuLy8gYmVjYXVzZSB0aGUgb3JpZ2luYWwgcGFja2FnZSB3YXMgZXhwZWN0aW5nIHJ4anMgNysgYXMgYSBwZWVyIGRlcCBhbmQgdGhhdCB3YXMgY29uZmxpY3Rpbmcgd2l0aCBtYW55IG90aGVyIGRlcGVuZGVuY2llc1xuLy8gRklYTUU6IHdoZW4gcnhqcyA3IGNhbiBiZSB1c2VkIGluIHRoZSBwcm9qZWN0LCByZW1vdmUgdGhpcyBhbmQgZG8gYG5wbSBpbnN0YWxsIG5neC10cmFuc2xhdGUtdGVzdGluZyAtLXNhdmUtZGV2YFxuXG5leHBvcnQgZGVjbGFyZSB0eXBlIExhbmd1YWdlVHJhbnNsYXRpb24gPVxuICB8IHN0cmluZ1xuICB8IHN0cmluZ1tdXG4gIHwgeyBbdHJhbnNsYXRpb25LZXk6IHN0cmluZ106IExhbmd1YWdlVHJhbnNsYXRpb24gfVxuXG4vKipcbiAqIExhbmd1YWdlVHJhbnNsYXRpb25zIHJlcHJlc2VudHMgYSBtYXBwaW5nIGJldHdlZW4gYSB0cmFuc2xhdGlvbiBrZXkgYW5kIHRoZSB0cmFuc2xhdGlvbiBmb3IgdGhhdCBrZXlcbiAqIG9yIHRvIG5lc3RlZCB0cmFuc2xhdGlvbiBrZXlzLlxuICpcbiAqIEBleHBvcnRcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBMYW5ndWFnZVRyYW5zbGF0aW9ucyB7XG4gIFt0cmFuc2xhdGlvbktleTogc3RyaW5nXTogTGFuZ3VhZ2VUcmFuc2xhdGlvblxufVxuXG4vKipcbiAqIFRyYW5zbGF0aW9ucyByZXByZXNlbnRzIGEgbWFwcGluZyBiZXR3ZWVuIGEgbGFuZ3VhZ2UgYW5kIHRoZSB0cmFuc2xhdGlvbnMgZm9yIHRoYXQgbGFuZ3VhZ2UuXG4gKlxuICogQGV4cG9ydFxuICovXG5leHBvcnQgaW50ZXJmYWNlIFRyYW5zbGF0aW9ucyB7XG4gIFtsYW5ndWFnZTogc3RyaW5nXTogTGFuZ3VhZ2VUcmFuc2xhdGlvbnNcbn1cbiJdfQ==

package/esm2022/libs/util/i18n/src/lib/translate.loader.utils.mjs

@@ -0,0 +1,8 @@
+export function dropEmptyTranslations(translations) {
+    // filter out empty keys: this should let us fallback on the default lang or
+    // untranslated key, instead of having a blank space
+    return Object.keys(translations).reduce((prev, curr) => translations[curr].trim().length
+        ? { ...prev, [curr]: translations[curr] }
+        : prev, {});
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRlLmxvYWRlci51dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvdXRpbC9pMThuL3NyYy9saWIvdHJhbnNsYXRlLmxvYWRlci51dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLFVBQVUscUJBQXFCLENBQUMsWUFBWTtJQUNoRCw0RUFBNEU7SUFDNUUsb0RBQW9EO0lBQ3BELE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQyxNQUFNLENBQ3JDLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxFQUFFLENBQ2IsWUFBWSxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDLE1BQU07UUFDOUIsQ0FBQyxDQUFDLEVBQUUsR0FBRyxJQUFJLEVBQUUsQ0FBQyxJQUFJLENBQUMsRUFBRSxZQUFZLENBQUMsSUFBSSxDQUFDLEVBQUU7UUFDekMsQ0FBQyxDQUFDLElBQUksRUFDVixFQUFFLENBQ0gsQ0FBQTtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gZHJvcEVtcHR5VHJhbnNsYXRpb25zKHRyYW5zbGF0aW9ucykge1xuICAvLyBmaWx0ZXIgb3V0IGVtcHR5IGtleXM6IHRoaXMgc2hvdWxkIGxldCB1cyBmYWxsYmFjayBvbiB0aGUgZGVmYXVsdCBsYW5nIG9yXG4gIC8vIHVudHJhbnNsYXRlZCBrZXksIGluc3RlYWQgb2YgaGF2aW5nIGEgYmxhbmsgc3BhY2VcbiAgcmV0dXJuIE9iamVjdC5rZXlzKHRyYW5zbGF0aW9ucykucmVkdWNlKFxuICAgIChwcmV2LCBjdXJyKSA9PlxuICAgICAgdHJhbnNsYXRpb25zW2N1cnJdLnRyaW0oKS5sZW5ndGhcbiAgICAgICAgPyB7IC4uLnByZXYsIFtjdXJyXTogdHJhbnNsYXRpb25zW2N1cnJdIH1cbiAgICAgICAgOiBwcmV2LFxuICAgIHt9XG4gIClcbn1cbiJdfQ==

package/esm2022/libs/util/i18n/src/lib/util-i18n.module.mjs

@@ -0,0 +1,37 @@
+import { HTTP_INTERCEPTORS, HttpClientModule } from '@angular/common/http';
+import { NgModule } from '@angular/core';
+import { TranslateModule, TranslateService } from '@ngx-translate/core';
+import { DEFAULT_LANG, LANGUAGE_STORAGE_KEY } from './i18n.constants';
+import { I18nInterceptor } from './i18n.interceptor';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class UtilI18nModule {
+    constructor(translate) {
+        translate.setDefaultLang(DEFAULT_LANG);
+        let storageLang = null;
+        try {
+            storageLang = localStorage.getItem(LANGUAGE_STORAGE_KEY);
+        }
+        catch (error) {
+            console.warn(error);
+        }
+        translate.use(storageLang || translate.getBrowserLang() || DEFAULT_LANG);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: UtilI18nModule, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: UtilI18nModule, imports: [HttpClientModule, i1.TranslateModule, CommonModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: UtilI18nModule, providers: [
+            { provide: HTTP_INTERCEPTORS, useClass: I18nInterceptor, multi: true },
+        ], imports: [HttpClientModule, TranslateModule.forChild(), CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: UtilI18nModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [HttpClientModule, TranslateModule.forChild(), CommonModule],
+                    exports: [],
+                    providers: [
+                        { provide: HTTP_INTERCEPTORS, useClass: I18nInterceptor, multi: true },
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/shared/src/index.mjs

@@ -0,0 +1,7 @@
+export * from './lib/util-shared.module';
+export * from './lib/services';
+export * from './lib/utils';
+export * from './lib/links';
+export * from './lib/pipes';
+export * from './lib/image-fallback.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3V0aWwvc2hhcmVkL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFBO0FBQ3hDLGNBQWMsZ0JBQWdCLENBQUE7QUFDOUIsY0FBYyxhQUFhLENBQUE7QUFDM0IsY0FBYyxhQUFhLENBQUE7QUFDM0IsY0FBYyxhQUFhLENBQUE7QUFDM0IsY0FBYyxnQ0FBZ0MsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL3V0aWwtc2hhcmVkLm1vZHVsZSdcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzJ1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdXRpbHMnXG5leHBvcnQgKiBmcm9tICcuL2xpYi9saW5rcydcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BpcGVzJ1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaW1hZ2UtZmFsbGJhY2suZGlyZWN0aXZlJ1xuIl19

package/esm2022/libs/util/shared/src/lib/image-fallback.directive.mjs

@@ -0,0 +1,27 @@
+import { Directive, ElementRef, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ImageFallbackDirective {
+    useFallback() {
+        const fallbackUrl = new URL(this.fallbackUrl, window.location.toString()).toString();
+        if (this.el.nativeElement.src !== fallbackUrl) {
+            this.el.nativeElement.src = fallbackUrl;
+        }
+    }
+    constructor(el) {
+        this.el = el;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: ImageFallbackDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: ImageFallbackDirective, selector: "img[gnUiImageFallback]", inputs: { fallbackUrl: "fallbackUrl" }, host: { listeners: { "error": "useFallback()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: ImageFallbackDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'img[gnUiImageFallback]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { fallbackUrl: [{
+                type: Input
+            }], useFallback: [{
+                type: HostListener,
+                args: ['error']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1hZ2UtZmFsbGJhY2suZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy91dGlsL3NoYXJlZC9zcmMvbGliL2ltYWdlLWZhbGxiYWNrLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFBOztBQUsxRSxNQUFNLE9BQU8sc0JBQXNCO0lBR2pDLFdBQVc7UUFDVCxNQUFNLFdBQVcsR0FBRyxJQUFJLEdBQUcsQ0FDekIsSUFBSSxDQUFDLFdBQVcsRUFDaEIsTUFBTSxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FDM0IsQ0FBQyxRQUFRLEVBQUUsQ0FBQTtRQUNaLElBQUksSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsR0FBRyxLQUFLLFdBQVcsRUFBRTtZQUM3QyxJQUFJLENBQUMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxHQUFHLEdBQUcsV0FBVyxDQUFBO1NBQ3hDO0lBQ0gsQ0FBQztJQUNELFlBQW9CLEVBQWM7UUFBZCxPQUFFLEdBQUYsRUFBRSxDQUFZO0lBQUcsQ0FBQzs4R0FaM0Isc0JBQXNCO2tHQUF0QixzQkFBc0I7OzJGQUF0QixzQkFBc0I7a0JBSGxDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHdCQUF3QjtpQkFDbkM7aUdBRVUsV0FBVztzQkFBbkIsS0FBSztnQkFFTixXQUFXO3NCQURWLFlBQVk7dUJBQUMsT0FBTyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgSG9zdExpc3RlbmVyLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ2ltZ1tnblVpSW1hZ2VGYWxsYmFja10nLFxufSlcbmV4cG9ydCBjbGFzcyBJbWFnZUZhbGxiYWNrRGlyZWN0aXZlIHtcbiAgQElucHV0KCkgZmFsbGJhY2tVcmw6IHN0cmluZ1xuICBASG9zdExpc3RlbmVyKCdlcnJvcicpXG4gIHVzZUZhbGxiYWNrKCkge1xuICAgIGNvbnN0IGZhbGxiYWNrVXJsID0gbmV3IFVSTChcbiAgICAgIHRoaXMuZmFsbGJhY2tVcmwsXG4gICAgICB3aW5kb3cubG9jYXRpb24udG9TdHJpbmcoKVxuICAgICkudG9TdHJpbmcoKVxuICAgIGlmICh0aGlzLmVsLm5hdGl2ZUVsZW1lbnQuc3JjICE9PSBmYWxsYmFja1VybCkge1xuICAgICAgdGhpcy5lbC5uYXRpdmVFbGVtZW50LnNyYyA9IGZhbGxiYWNrVXJsXG4gICAgfVxuICB9XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgZWw6IEVsZW1lbnRSZWYpIHt9XG59XG4iXX0=

package/esm2022/libs/util/shared/src/lib/links/index.mjs

@@ -0,0 +1,3 @@
+export * from './link-utils';
+export * from './link-classifier.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3V0aWwvc2hhcmVkL3NyYy9saWIvbGlua3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUE7QUFDNUIsY0FBYywyQkFBMkIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGluay11dGlscydcbmV4cG9ydCAqIGZyb20gJy4vbGluay1jbGFzc2lmaWVyLnNlcnZpY2UnXG4iXX0=

package/esm2022/libs/util/shared/src/lib/links/link-classifier.service.mjs

@@ -0,0 +1,60 @@
+import { Injectable } from '@angular/core';
+import { getFileFormat } from './link-utils';
+import * as i0 from "@angular/core";
+export var LinkUsage;
+(function (LinkUsage) {
+    LinkUsage["API"] = "api";
+    LinkUsage["MAP_API"] = "mapapi";
+    LinkUsage["DOWNLOAD"] = "download";
+    LinkUsage["DATA"] = "data";
+    LinkUsage["GEODATA"] = "geodata";
+    LinkUsage["LANDING_PAGE"] = "landingpage";
+    LinkUsage["UNKNOWN"] = "unknown";
+})(LinkUsage || (LinkUsage = {}));
+export class LinkClassifierService {
+    getUsagesForLink(link) {
+        switch (link.type) {
+            case 'service': {
+                switch (link.accessServiceProtocol) {
+                    case 'esriRest':
+                    case 'wfs':
+                        return [LinkUsage.API, LinkUsage.DOWNLOAD, LinkUsage.GEODATA];
+                    case 'wms':
+                    case 'wmts':
+                        return [LinkUsage.API, LinkUsage.MAP_API];
+                    default:
+                        return [LinkUsage.UNKNOWN];
+                }
+            }
+            case 'link':
+                return [LinkUsage.UNKNOWN];
+            case 'download': {
+                switch (getFileFormat(link)) {
+                    case 'json':
+                    case 'csv':
+                    case 'excel':
+                        return [LinkUsage.DOWNLOAD, LinkUsage.DATA];
+                    case 'geojson':
+                        return [LinkUsage.DOWNLOAD, LinkUsage.GEODATA];
+                    default:
+                        if (link.url.toString().match(/\/wfs/i)) {
+                            return [LinkUsage.DOWNLOAD, LinkUsage.GEODATA];
+                        }
+                        return [LinkUsage.DOWNLOAD];
+                }
+            }
+        }
+    }
+    hasUsage(link, usage) {
+        return this.getUsagesForLink(link).indexOf(usage) > -1;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: LinkClassifierService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: LinkClassifierService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: LinkClassifierService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/shared/src/lib/links/link-utils.mjs

@@ -0,0 +1,183 @@
+import { marker } from '@biesbjerg/ngx-translate-extract-marker';
+marker('downloads.wfs.featuretype.not.found');
+export const FORMATS = {
+    csv: {
+        extensions: ['csv'],
+        priority: 1,
+        color: '#559d7f',
+        mimeTypes: ['text/csv', 'application/csv'],
+    },
+    excel: {
+        extensions: [
+            'excel',
+            'xls',
+            'xlsx',
+            'ms-excel',
+            'openxmlformats-officedocument',
+        ],
+        priority: 2,
+        color: '#0f4395',
+        mimeTypes: [
+            'application/vnd.ms-excel',
+            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        ],
+    },
+    geojson: {
+        extensions: ['geojson'],
+        priority: 3,
+        color: '#1e5180',
+        mimeTypes: ['application/geo+json', 'application/vnd.geo+json'],
+    },
+    json: {
+        extensions: ['json'],
+        priority: 3,
+        color: '#1e5180',
+        mimeTypes: ['application/json'],
+    },
+    shp: {
+        extensions: ['shp', 'shape', 'zipped-shapefile'],
+        priority: 4,
+        color: '#328556',
+        mimeTypes: ['x-gis/x-shapefile'],
+    },
+    kml: {
+        extensions: ['kml', 'kmz'],
+        priority: 5,
+        color: '#348009',
+        mimeTypes: [
+            'application/vnd.google-earth.kml+xml',
+            'application/vnd.google-earth.kmz',
+        ],
+    },
+    gpkg: {
+        extensions: ['gpkg', 'geopackage'],
+        priority: 6,
+        color: '#ea79ba',
+        mimeTypes: ['application/geopackage+sqlite3'],
+    },
+    zip: {
+        extensions: ['zip'],
+        priority: 7,
+        color: '#f2bb3a',
+        mimeTypes: ['application/zip'],
+    },
+    pdf: {
+        extensions: ['pdf'],
+        priority: 8,
+        color: '#db544a',
+        mimeTypes: ['application/pdf'],
+    },
+    jpg: {
+        extensions: ['jpg', 'jpeg', 'jfif', 'pjpeg', 'pjp'],
+        priority: 8,
+        color: '#673ab7',
+        mimeTypes: ['image/jpg'],
+    },
+    svg: {
+        extensions: ['svg'],
+        priority: 9,
+        color: '#d98294',
+        mimeTypes: ['image/svg+xml'],
+    },
+};
+export function getFormatPriority(linkFormat) {
+    for (const format in FORMATS) {
+        for (const ext of FORMATS[format].extensions) {
+            if (new RegExp(`${ext}`, 'i').test(linkFormat)) {
+                if (FORMATS[format].priority === 0)
+                    return 0;
+                return Object.keys(FORMATS).length - FORMATS[format].priority;
+            }
+        }
+    }
+    return 0;
+}
+export function getLinkPriority(link) {
+    return getFormatPriority(getFileFormat(link));
+}
+export function extensionToFormat(extension) {
+    for (const format in FORMATS) {
+        for (const alias of FORMATS[format].extensions) {
+            if (alias === extension.toLowerCase())
+                return format;
+        }
+    }
+    return undefined;
+}
+export function getFileFormat(link) {
+    if ('mimeType' in link) {
+        return mimeTypeToFormat(link.mimeType);
+    }
+    for (const format in FORMATS) {
+        for (const alias of FORMATS[format].extensions) {
+            if (checkFileFormat(link, alias))
+                return format;
+            if (isFormatInQueryParam(link, alias))
+                return format;
+        }
+    }
+    return null;
+}
+export function isFormatInQueryParam(link, alias) {
+    const queryParams = link.url.searchParams;
+    for (const [key, value] of queryParams.entries()) {
+        if (key === 'format' || key === 'f') {
+            return value === alias;
+        }
+    }
+    return false;
+}
+export function mimeTypeToFormat(mimeType) {
+    for (const format in FORMATS) {
+        for (const mt of FORMATS[format].mimeTypes) {
+            if (mimeType === mt)
+                return format;
+        }
+    }
+    return undefined;
+}
+export function checkFileFormat(link, format) {
+    return (('name' in link && new RegExp(`[./]${format}`, 'i').test(link.name)) ||
+        ('url' in link &&
+            new RegExp(`[./]${format}`, 'i').test(link.url.toString())));
+}
+export function getBadgeColor(linkFormat) {
+    for (const format in FORMATS) {
+        for (const alias of FORMATS[format].extensions) {
+            if (new RegExp(`${alias}`, 'i').test(linkFormat))
+                return FORMATS[format].color;
+        }
+    }
+    return 'var(--color-gray-700)'; // Default color ?
+}
+export function getLinkLabel(link) {
+    let format = '';
+    switch (link.type) {
+        case 'service':
+            {
+                switch (link.accessServiceProtocol) {
+                    case 'wfs':
+                        format = 'WFS';
+                        break;
+                    case 'wms':
+                        format = 'WMS';
+                        break;
+                    case 'wmts':
+                        format = 'WMTS';
+                        break;
+                    case 'esriRest':
+                        format = 'REST';
+                        break;
+                }
+            }
+            break;
+        default:
+            format = getFileFormat(link);
+    }
+    const label = link.description || link.name;
+    return format ? `${label} (${format})` : label;
+}
+export function getMimeTypeForFormat(format) {
+    return format in FORMATS ? FORMATS[format.toLowerCase()].mimeTypes[0] : null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"link-utils.js","sourceRoot":"","sources":["../../../../../../../../libs/util/shared/src/lib/links/link-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { marker } from '@biesbjerg/ngx-translate-extract-marker'\nimport { DatasetDistribution } from '../../../../../../libs/common/domain/src/lib/record'\n\nmarker('downloads.wfs.featuretype.not.found')\n\nexport const FORMATS = {\n  csv: {\n    extensions: ['csv'],\n    priority: 1,\n    color: '#559d7f',\n    mimeTypes: ['text/csv', 'application/csv'],\n  },\n  excel: {\n    extensions: [\n      'excel',\n      'xls',\n      'xlsx',\n      'ms-excel',\n      'openxmlformats-officedocument',\n    ],\n    priority: 2,\n    color: '#0f4395',\n    mimeTypes: [\n      'application/vnd.ms-excel',\n      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n    ],\n  },\n  geojson: {\n    extensions: ['geojson'],\n    priority: 3,\n    color: '#1e5180',\n    mimeTypes: ['application/geo+json', 'application/vnd.geo+json'],\n  },\n  json: {\n    extensions: ['json'],\n    priority: 3,\n    color: '#1e5180',\n    mimeTypes: ['application/json'],\n  },\n  shp: {\n    extensions: ['shp', 'shape', 'zipped-shapefile'],\n    priority: 4,\n    color: '#328556',\n    mimeTypes: ['x-gis/x-shapefile'],\n  },\n  kml: {\n    extensions: ['kml', 'kmz'],\n    priority: 5,\n    color: '#348009',\n    mimeTypes: [\n      'application/vnd.google-earth.kml+xml',\n      'application/vnd.google-earth.kmz',\n    ],\n  },\n  gpkg: {\n    extensions: ['gpkg', 'geopackage'],\n    priority: 6,\n    color: '#ea79ba',\n    mimeTypes: ['application/geopackage+sqlite3'],\n  },\n  zip: {\n    extensions: ['zip'],\n    priority: 7,\n    color: '#f2bb3a',\n    mimeTypes: ['application/zip'],\n  },\n  pdf: {\n    extensions: ['pdf'],\n    priority: 8,\n    color: '#db544a',\n    mimeTypes: ['application/pdf'],\n  },\n  jpg: {\n    extensions: ['jpg', 'jpeg', 'jfif', 'pjpeg', 'pjp'],\n    priority: 8,\n    color: '#673ab7',\n    mimeTypes: ['image/jpg'],\n  },\n  svg: {\n    extensions: ['svg'],\n    priority: 9,\n    color: '#d98294',\n    mimeTypes: ['image/svg+xml'],\n  },\n} as const\n\nexport type FileFormat = keyof typeof FORMATS\n\nexport function getFormatPriority(linkFormat: FileFormat): number {\n  for (const format in FORMATS) {\n    for (const ext of FORMATS[format].extensions) {\n      if (new RegExp(`${ext}`, 'i').test(linkFormat)) {\n        if (FORMATS[format].priority === 0) return 0\n        return Object.keys(FORMATS).length - FORMATS[format].priority\n      }\n    }\n  }\n  return 0\n}\n\nexport function getLinkPriority(link: DatasetDistribution): number {\n  return getFormatPriority(getFileFormat(link))\n}\n\nexport function extensionToFormat(extension: string): FileFormat {\n  for (const format in FORMATS) {\n    for (const alias of FORMATS[format].extensions) {\n      if (alias === extension.toLowerCase()) return format as FileFormat\n    }\n  }\n  return undefined\n}\n\nexport function getFileFormat(link: DatasetDistribution): FileFormat {\n  if ('mimeType' in link) {\n    return mimeTypeToFormat(link.mimeType)\n  }\n  for (const format in FORMATS) {\n    for (const alias of FORMATS[format].extensions) {\n      if (checkFileFormat(link, alias)) return format as FileFormat\n      if (isFormatInQueryParam(link, alias)) return format as FileFormat\n    }\n  }\n  return null\n}\n\nexport function isFormatInQueryParam(\n  link: DatasetDistribution,\n  alias: string\n): boolean {\n  const queryParams = link.url.searchParams\n  for (const [key, value] of queryParams.entries()) {\n    if (key === 'format' || key === 'f') {\n      return value === alias\n    }\n  }\n  return false\n}\n\nexport function mimeTypeToFormat(mimeType: string): FileFormat {\n  for (const format in FORMATS) {\n    for (const mt of FORMATS[format].mimeTypes) {\n      if (mimeType === mt) return format as FileFormat\n    }\n  }\n  return undefined\n}\n\nexport function checkFileFormat(\n  link: DatasetDistribution,\n  format: FileFormat\n): boolean {\n  return (\n    ('name' in link && new RegExp(`[./]${format}`, 'i').test(link.name)) ||\n    ('url' in link &&\n      new RegExp(`[./]${format}`, 'i').test(link.url.toString()))\n  )\n}\n\nexport function getBadgeColor(linkFormat: FileFormat): string {\n  for (const format in FORMATS) {\n    for (const alias of FORMATS[format].extensions) {\n      if (new RegExp(`${alias}`, 'i').test(linkFormat))\n        return FORMATS[format].color\n    }\n  }\n  return 'var(--color-gray-700)' // Default color ?\n}\n\nexport function getLinkLabel(link: DatasetDistribution): string {\n  let format = ''\n  switch (link.type) {\n    case 'service':\n      {\n        switch (link.accessServiceProtocol) {\n          case 'wfs':\n            format = 'WFS'\n            break\n          case 'wms':\n            format = 'WMS'\n            break\n          case 'wmts':\n            format = 'WMTS'\n            break\n          case 'esriRest':\n            format = 'REST'\n            break\n        }\n      }\n      break\n    default:\n      format = getFileFormat(link)\n  }\n  const label = link.description || link.name\n  return format ? `${label} (${format})` : label\n}\n\nexport function getMimeTypeForFormat(format: FileFormat): string | null {\n  return format in FORMATS ? FORMATS[format.toLowerCase()].mimeTypes[0] : null\n}\n"]}

package/esm2022/libs/util/shared/src/lib/pipes/SafePipe.mjs

@@ -0,0 +1,34 @@
+import { Pipe } from '@angular/core';
+import { DomSanitizer, } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class SafePipe {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(value, type) {
+        switch (type) {
+            case 'html':
+                return this.sanitizer.bypassSecurityTrustHtml(value);
+            case 'style':
+                return this.sanitizer.bypassSecurityTrustStyle(value);
+            case 'script':
+                return this.sanitizer.bypassSecurityTrustScript(value);
+            case 'url':
+                return this.sanitizer.bypassSecurityTrustUrl(value);
+            case 'resourceUrl':
+                return this.sanitizer.bypassSecurityTrustResourceUrl(value);
+            default:
+                throw new Error(`Invalid safe type specified: ${type}`);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SafePipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: SafePipe, name: "safe" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SafePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'safe',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/shared/src/lib/pipes/index.mjs

@@ -0,0 +1,2 @@
+export * from './SafePipe';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3V0aWwvc2hhcmVkL3NyYy9saWIvcGlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL1NhZmVQaXBlJ1xuIl19

package/esm2022/libs/util/shared/src/lib/services/index.mjs

@@ -0,0 +1,4 @@
+export * from './theme.service';
+export * from './log.service';
+export * from './proxy.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3V0aWwvc2hhcmVkL3NyYy9saWIvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQTtBQUMvQixjQUFjLGVBQWUsQ0FBQTtBQUM3QixjQUFjLGlCQUFpQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90aGVtZS5zZXJ2aWNlJ1xuZXhwb3J0ICogZnJvbSAnLi9sb2cuc2VydmljZSdcbmV4cG9ydCAqIGZyb20gJy4vcHJveHkuc2VydmljZSdcbiJdfQ==

package/esm2022/libs/util/shared/src/lib/services/log.service.mjs

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LogService {
+    log(message, ...objects) {
+        console.log.apply(this, [message, ...objects]);
+    }
+    warn(message, ...objects) {
+        console.warn.apply(this, [message, ...objects]);
+    }
+    error(message, ...objects) {
+        console.error.apply(this, [message, ...objects]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: LogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: LogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: LogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3V0aWwvc2hhcmVkL3NyYy9saWIvc2VydmljZXMvbG9nLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQTs7QUFLMUMsTUFBTSxPQUFPLFVBQVU7SUFDckIsR0FBRyxDQUFDLE9BQWUsRUFBRSxHQUFHLE9BQWM7UUFDcEMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsT0FBTyxFQUFFLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQTtJQUNoRCxDQUFDO0lBQ0QsSUFBSSxDQUFDLE9BQWUsRUFBRSxHQUFHLE9BQWM7UUFDckMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsT0FBTyxFQUFFLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQTtJQUNqRCxDQUFDO0lBQ0QsS0FBSyxDQUFDLE9BQWUsRUFBRSxHQUFHLE9BQWM7UUFDdEMsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsT0FBTyxFQUFFLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQTtJQUNsRCxDQUFDOzhHQVRVLFVBQVU7a0hBQVYsVUFBVSxjQUZULE1BQU07OzJGQUVQLFVBQVU7a0JBSHRCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBMb2dTZXJ2aWNlIHtcbiAgbG9nKG1lc3NhZ2U6IHN0cmluZywgLi4ub2JqZWN0czogYW55W10pOiB2b2lkIHtcbiAgICBjb25zb2xlLmxvZy5hcHBseSh0aGlzLCBbbWVzc2FnZSwgLi4ub2JqZWN0c10pXG4gIH1cbiAgd2FybihtZXNzYWdlOiBzdHJpbmcsIC4uLm9iamVjdHM6IGFueVtdKTogdm9pZCB7XG4gICAgY29uc29sZS53YXJuLmFwcGx5KHRoaXMsIFttZXNzYWdlLCAuLi5vYmplY3RzXSlcbiAgfVxuICBlcnJvcihtZXNzYWdlOiBzdHJpbmcsIC4uLm9iamVjdHM6IGFueVtdKTogdm9pZCB7XG4gICAgY29uc29sZS5lcnJvci5hcHBseSh0aGlzLCBbbWVzc2FnZSwgLi4ub2JqZWN0c10pXG4gIH1cbn1cbiJdfQ==