geonetwork-ui 2.1.0-initial

package/README.md

@@ -0,0 +1,55 @@
+# GeoNetwork-UI NPM Package
+
+## What is it?
+
+This package contains many of the features available in the [GeoNetwork-UI project](https://github.com/geonetwork/geonetwork-ui/actions).
+
+Its contents are:
+
+- all the libraries in the `libs` folder
+- all translations
+- various configuration files
+
+This package _does not_ contain:
+
+- applications (Datahub, etc.)
+- unit and E2E tests
+- docker composition
+- documentation
+- anything related to [NX](https://nx.dev/)
+
+## How can I use it?
+
+This is what using this package looks like in an Angular application:
+
+```ts
+// ...
+import {
+  UiElementsModule,
+  UiInputsModule,
+  UiWidgetsModule,
+  provideRepositoryUrl,
+  ThemeService
+} from 'geonetwork-ui'
+
+@NgModule({
+  imports: [
+    // ...
+    UiWidgetsModule,
+    UiElementsModule,
+    UiInputsModule,
+  ],
+  providers: [
+    // ...
+    provideRepositoryUrl('http://localhost:8080/geonetwork/srv/api'),
+  ],
+  bootstrap: [AppComponent],
+})
+export class AppModule {
+  constructor() {
+    ThemeService.applyCssVariables('#e73f51', '#c2e9dc', '#212029', '#fdfbff');
+  }
+}
+```
+
+Please read the documentation on [how to create a Custom Application](https://geonetwork.github.io/geonetwork-ui/main/docs/guide/custom-app.html) for more information!

package/esm2022/geonetwork-ui.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VvbmV0d29yay11aS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL2dlb25ldHdvcmstdWkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/index.mjs

@@ -0,0 +1,24 @@
+// This file contains everything that will be included in the NPM package!
+export * from './libs/api/metadata-converter/src';
+export * from './libs/api/repository/src';
+export * from './libs/feature/auth/src';
+export * from './libs/feature/map/src';
+export * from './libs/feature/search/src';
+export * from './libs/feature/record/src';
+export * from './libs/feature/dataviz/src';
+export * from './libs/feature/catalog/src';
+export * from './libs/feature/editor/src';
+export * from './libs/feature/router/src';
+export * from './libs/ui/map/src';
+export * from './libs/ui/catalog/src';
+export * from './libs/ui/dataviz/src';
+export * from './libs/ui/search/src';
+export * from './libs/ui/widgets/src';
+export * from './libs/ui/inputs/src';
+export * from './libs/ui/elements/src';
+export * from './libs/ui/layout/src';
+export * from './libs/util/shared/src';
+export * from './libs/util/i18n/src';
+export * from './libs/util/app-config/src';
+export * from './libs/util/data-fetcher/src';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/api/metadata-converter/src/index.mjs

@@ -0,0 +1,5 @@
+export * from './lib/iso19139/converter';
+export * from './lib/gn4/gn4.metadata.mapper';
+export * from './lib/gn4/atomic-operations';
+export * from './lib/gn4/types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FwaS9tZXRhZGF0YS1jb252ZXJ0ZXIvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUE7QUFDeEMsY0FBYywrQkFBK0IsQ0FBQTtBQUM3QyxjQUFjLDZCQUE2QixDQUFBO0FBQzNDLGNBQWMsaUJBQWlCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9pc28xOTEzOS9jb252ZXJ0ZXInXG5leHBvcnQgKiBmcm9tICcuL2xpYi9nbjQvZ240Lm1ldGFkYXRhLm1hcHBlcidcbmV4cG9ydCAqIGZyb20gJy4vbGliL2duNC9hdG9taWMtb3BlcmF0aW9ucydcbmV4cG9ydCAqIGZyb20gJy4vbGliL2duNC90eXBlcydcbiJdfQ==

package/esm2022/libs/api/metadata-converter/src/lib/common/distribution.mapper.mjs

@@ -0,0 +1,20 @@
+export function matchProtocol(protocol) {
+    if (/wms/i.test(protocol))
+        return 'wms';
+    if (/wfs/i.test(protocol))
+        return 'wfs';
+    if (/wmts/i.test(protocol))
+        return 'wmts';
+    if (/wps/i.test(protocol))
+        return 'wps';
+    if (/esri/i.test(protocol))
+        return 'esriRest';
+    return 'other';
+}
+export function matchMimeType(format) {
+    if (/shp|shapefile/i.test(format))
+        return 'x-gis/x-shapefile';
+    // TODO: check whether the format is a valid mime type
+    return format || null;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzdHJpYnV0aW9uLm1hcHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYXBpL21ldGFkYXRhLWNvbnZlcnRlci9zcmMvbGliL2NvbW1vbi9kaXN0cmlidXRpb24ubWFwcGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSxhQUFhLENBQUMsUUFBZ0I7SUFDNUMsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQztRQUFFLE9BQU8sS0FBSyxDQUFBO0lBQ3ZDLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUM7UUFBRSxPQUFPLEtBQUssQ0FBQTtJQUN2QyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDO1FBQUUsT0FBTyxNQUFNLENBQUE7SUFDekMsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQztRQUFFLE9BQU8sS0FBSyxDQUFBO0lBQ3ZDLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUM7UUFBRSxPQUFPLFVBQVUsQ0FBQTtJQUM3QyxPQUFPLE9BQU8sQ0FBQTtBQUNoQixDQUFDO0FBRUQsTUFBTSxVQUFVLGFBQWEsQ0FBQyxNQUFjO0lBQzFDLElBQUksZ0JBQWdCLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUFFLE9BQU8sbUJBQW1CLENBQUE7SUFDN0Qsc0RBQXNEO0lBQ3RELE9BQU8sTUFBTSxJQUFJLElBQUksQ0FBQTtBQUN2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VydmljZVByb3RvY29sIH0gZnJvbSAnLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vZG9tYWluL3NyYy9saWIvcmVjb3JkJ1xuXG5leHBvcnQgZnVuY3Rpb24gbWF0Y2hQcm90b2NvbChwcm90b2NvbDogc3RyaW5nKTogU2VydmljZVByb3RvY29sIHtcbiAgaWYgKC93bXMvaS50ZXN0KHByb3RvY29sKSkgcmV0dXJuICd3bXMnXG4gIGlmICgvd2ZzL2kudGVzdChwcm90b2NvbCkpIHJldHVybiAnd2ZzJ1xuICBpZiAoL3dtdHMvaS50ZXN0KHByb3RvY29sKSkgcmV0dXJuICd3bXRzJ1xuICBpZiAoL3dwcy9pLnRlc3QocHJvdG9jb2wpKSByZXR1cm4gJ3dwcydcbiAgaWYgKC9lc3JpL2kudGVzdChwcm90b2NvbCkpIHJldHVybiAnZXNyaVJlc3QnXG4gIHJldHVybiAnb3RoZXInXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBtYXRjaE1pbWVUeXBlKGZvcm1hdDogc3RyaW5nKTogc3RyaW5nIHtcbiAgaWYgKC9zaHB8c2hhcGVmaWxlL2kudGVzdChmb3JtYXQpKSByZXR1cm4gJ3gtZ2lzL3gtc2hhcGVmaWxlJ1xuICAvLyBUT0RPOiBjaGVjayB3aGV0aGVyIHRoZSBmb3JtYXQgaXMgYSB2YWxpZCBtaW1lIHR5cGVcbiAgcmV0dXJuIGZvcm1hdCB8fCBudWxsXG59XG4iXX0=

package/esm2022/libs/api/metadata-converter/src/lib/convert-utils.mjs

@@ -0,0 +1,19 @@
+export function isEqual(a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((e, i) => isEqual(e, b[i]));
+    }
+    else if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+    }
+    else if (a instanceof URL && b instanceof URL) {
+        return a.toString() === b.toString();
+    }
+    else if (a instanceof Object && b instanceof Object) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        return (aKeys.length === bKeys.length &&
+            aKeys.every((key) => isEqual(a[key], b[key])));
+    }
+    return a === b;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/api/metadata-converter/src/lib/function-utils.mjs

@@ -0,0 +1,40 @@
+export function pipe(...fns) {
+    return (value) => fns.reduce((prev, curr) => curr(prev), value);
+}
+export function map(mapper) {
+    return (input) => mapper(input);
+}
+export function mapArray(mapper) {
+    return (input) => input.map(mapper);
+}
+export function filterArray(filter) {
+    return (input) => input.filter(filter);
+}
+export function flattenArray() {
+    return (input) => input.flat();
+}
+export function getAtIndex(index) {
+    return (input) => (input.length > index ? input[index] : null);
+}
+export function fallback(...fns) {
+    return (value) => {
+        for (let i = 0; i < fns.length; i++) {
+            const result = fns[i](value);
+            if (result !== null) {
+                return result;
+            }
+        }
+        return null;
+    };
+}
+export function combine(...fns) {
+    return (value) => fns.map((fn) => fn(value));
+}
+export function tap(fn) {
+    return (value) => {
+        fn(value);
+        return value;
+    };
+}
+export const noop = (value) => value;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-utils.js","sourceRoot":"","sources":["../../../../../../../libs/api/metadata-converter/src/lib/function-utils.ts"],"names":[],"mappings":"AA8EA,MAAM,UAAU,IAAI,CAClB,GAAG,GAA+C;IAElD,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,CAAA;AACjE,CAAC;AAED,MAAM,UAAU,GAAG,CAAO,MAAoB;IAC5C,OAAO,CAAC,KAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AACpC,CAAC;AAED,MAAM,UAAU,QAAQ,CAAO,MAAoB;IACjD,OAAO,CAAC,KAAe,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;AAC/C,CAAC;AAED,MAAM,UAAU,WAAW,CAAI,MAA0B;IACvD,OAAO,CAAC,KAAe,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;AAClD,CAAC;AAED,MAAM,UAAU,YAAY;IAC1B,OAAO,CAAC,KAAe,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAA;AAC1C,CAAC;AAED,MAAM,UAAU,UAAU,CAAI,KAAa;IACzC,OAAO,CAAC,KAAe,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;AAC1E,CAAC;AAED,MAAM,UAAU,QAAQ,CACtB,GAAG,GAAmC;IAEtC,OAAO,CAAC,KAAQ,EAAE,EAAE;QAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACnC,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAA;YAC5B,IAAI,MAAM,KAAK,IAAI,EAAE;gBACnB,OAAO,MAAM,CAAA;aACd;SACF;QACD,OAAO,IAAI,CAAA;IACb,CAAC,CAAA;AACH,CAAC;AAyCD,MAAM,UAAU,OAAO,CACrB,GAAG,GAA+C;IAElD,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;AAC9C,CAAC;AAED,MAAM,UAAU,GAAG,CAAI,EAAsB;IAC3C,OAAO,CAAC,KAAQ,EAAE,EAAE;QAClB,EAAE,CAAC,KAAK,CAAC,CAAA;QACT,OAAO,KAAK,CAAA;IACd,CAAC,CAAA;AACH,CAAC;AAED,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAA","sourcesContent":["export type ChainableFunction<T, U> = (input: T) => U\n\nexport function pipe(): ChainableFunction<void, void>\nexport function pipe<U, V>(\n  fn1: ChainableFunction<U, V>\n): ChainableFunction<U, V>\nexport function pipe<U, V, W>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<V, W>\n): ChainableFunction<U, W>\nexport function pipe<U, V, W, X>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<V, W>,\n  fn3: ChainableFunction<W, X>\n): ChainableFunction<U, X>\nexport function pipe<U, V, W, X, Y>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<V, W>,\n  fn3: ChainableFunction<W, X>,\n  fn4: ChainableFunction<X, Y>\n): ChainableFunction<U, Y>\nexport function pipe<U, V, W, X, Y, Z>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<V, W>,\n  fn3: ChainableFunction<W, X>,\n  fn4: ChainableFunction<X, Y>,\n  fn5: ChainableFunction<Y, Z>\n): ChainableFunction<U, Z>\nexport function pipe<U, V, W, X, Y, Z, A>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<V, W>,\n  fn3: ChainableFunction<W, X>,\n  fn4: ChainableFunction<X, Y>,\n  fn5: ChainableFunction<Y, Z>,\n  fn6: ChainableFunction<Z, A>\n): ChainableFunction<U, A>\nexport function pipe<U, V, W, X, Y, Z, A, B>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<V, W>,\n  fn3: ChainableFunction<W, X>,\n  fn4: ChainableFunction<X, Y>,\n  fn5: ChainableFunction<Y, Z>,\n  fn6: ChainableFunction<Z, A>,\n  fn7: ChainableFunction<A, B>\n): ChainableFunction<U, B>\nexport function pipe<U, V, W, X, Y, Z, A, B, C>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<V, W>,\n  fn3: ChainableFunction<W, X>,\n  fn4: ChainableFunction<X, Y>,\n  fn5: ChainableFunction<Y, Z>,\n  fn6: ChainableFunction<Z, A>,\n  fn7: ChainableFunction<A, B>,\n  fn8: ChainableFunction<B, C>\n): ChainableFunction<U, C>\nexport function pipe<U, V, W, X, Y, Z, A, B, C, D>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<V, W>,\n  fn3: ChainableFunction<W, X>,\n  fn4: ChainableFunction<X, Y>,\n  fn5: ChainableFunction<Y, Z>,\n  fn6: ChainableFunction<Z, A>,\n  fn7: ChainableFunction<A, B>,\n  fn8: ChainableFunction<B, C>,\n  fn9: ChainableFunction<C, D>\n): ChainableFunction<U, D>\nexport function pipe<U, V, W, X, Y, Z, A, B, C, D, E>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<V, W>,\n  fn3: ChainableFunction<W, X>,\n  fn4: ChainableFunction<X, Y>,\n  fn5: ChainableFunction<Y, Z>,\n  fn6: ChainableFunction<Z, A>,\n  fn7: ChainableFunction<A, B>,\n  fn8: ChainableFunction<B, C>,\n  fn9: ChainableFunction<C, D>,\n  fn10: ChainableFunction<D, E>\n): ChainableFunction<U, E>\nexport function pipe(\n  ...fns: Array<ChainableFunction<unknown, unknown>>\n): ChainableFunction<unknown, unknown> {\n  return (value) => fns.reduce((prev, curr) => curr(prev), value)\n}\n\nexport function map<U, V>(mapper: (el: U) => V) {\n  return (input: U) => mapper(input)\n}\n\nexport function mapArray<U, V>(mapper: (el: U) => V) {\n  return (input: Array<U>) => input.map(mapper)\n}\n\nexport function filterArray<U>(filter: (el: U) => boolean) {\n  return (input: Array<U>) => input.filter(filter)\n}\n\nexport function flattenArray<U>() {\n  return (input: Array<U>) => input.flat()\n}\n\nexport function getAtIndex<U>(index: number) {\n  return (input: Array<U>) => (input.length > index ? input[index] : null)\n}\n\nexport function fallback<U, V>(\n  ...fns: Array<ChainableFunction<U, V>>\n): ChainableFunction<U, V> {\n  return (value: U) => {\n    for (let i = 0; i < fns.length; i++) {\n      const result = fns[i](value)\n      if (result !== null) {\n        return result\n      }\n    }\n    return null\n  }\n}\n\nexport function combine<U, V, W>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<U, W>\n): ChainableFunction<U, [V, W]>\nexport function combine<U, V, W, X>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<U, W>,\n  fn3: ChainableFunction<U, X>\n): ChainableFunction<U, [V, W, X]>\nexport function combine<U, V, W, X, Y>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<U, W>,\n  fn3: ChainableFunction<U, X>,\n  fn4: ChainableFunction<U, Y>\n): ChainableFunction<U, [V, W, X, Y]>\nexport function combine<U, V, W, X, Y, Z>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<U, W>,\n  fn3: ChainableFunction<U, X>,\n  fn4: ChainableFunction<U, Y>,\n  fn5: ChainableFunction<U, Z>\n): ChainableFunction<U, [V, W, X, Y, Z]>\nexport function combine<U, V, W, X, Y, Z, A>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<U, W>,\n  fn3: ChainableFunction<U, X>,\n  fn4: ChainableFunction<U, Y>,\n  fn5: ChainableFunction<U, Z>,\n  fn6: ChainableFunction<U, A>\n): ChainableFunction<U, [V, W, X, Y, Z, A]>\nexport function combine<U, V, W, X, Y, Z, A, B>(\n  fn1: ChainableFunction<U, V>,\n  fn2: ChainableFunction<U, W>,\n  fn3: ChainableFunction<U, X>,\n  fn4: ChainableFunction<U, Y>,\n  fn5: ChainableFunction<U, Z>,\n  fn6: ChainableFunction<U, A>,\n  fn7: ChainableFunction<U, B>\n): ChainableFunction<U, [V, W, X, Y, Z, A, B]>\nexport function combine(\n  ...fns: Array<ChainableFunction<unknown, unknown>>\n): ChainableFunction<unknown, Array<unknown>> {\n  return (value) => fns.map((fn) => fn(value))\n}\n\nexport function tap<U>(fn: (value: U) => void) {\n  return (value: U) => {\n    fn(value)\n    return value\n  }\n}\n\nexport const noop = (value) => value\n"]}

package/esm2022/libs/api/metadata-converter/src/lib/gn4/atomic-operations.mjs

@@ -0,0 +1,49 @@
+import { getRoleFromRoleCode } from '../iso19139/codelists/role.mapper';
+export const selectField = (source, fieldName) => source !== null && fieldName in source ? source[fieldName] : null;
+export const selectFallbackFields = (source, ...fieldNames) => fieldNames.reduce((prev, curr) => (prev === null ? selectField(source, curr) : prev), null);
+export const selectFallback = (field, fallback) => field === null ? fallback : field;
+export const selectTranslatedValue = (source, lang3) => selectFallback(selectField(source, lang3), selectField(source, 'default'));
+export const selectTranslatedField = (source, fieldName, lang3) => selectTranslatedValue(selectField(source, fieldName), lang3);
+export const toDate = (field) => new Date(field);
+export const getFirstValue = (field) => Array.isArray(field) ? field[0] : field;
+export const getAsArray = (field) => Array.isArray(field) ? field : field !== null ? [field] : [];
+export const getAsUrl = (field, location = window.location.toString()) => {
+    // an empty string is not a valid url, even though it could be considered an empty path to the root
+    if (field === '' || field === null)
+        return null;
+    let url = field;
+    if (field.match(/^www\./))
+        url = `https://${field}`;
+    try {
+        return new URL(url, location);
+    }
+    catch {
+        return null;
+    }
+};
+export const mapLogo = (source) => {
+    const logo = selectFallbackFields(source, 'logoUrl', 'logo');
+    return logo ? getAsUrl(`/geonetwork${logo}`) : null;
+};
+export const mapOrganization = (sourceContact, lang3) => {
+    const website = getAsUrl(selectField(sourceContact, 'website'));
+    const logoUrl = getAsUrl(selectField(sourceContact, 'logo'));
+    return {
+        name: selectFallback(selectTranslatedField(sourceContact, 'organisationObject', lang3), selectField(sourceContact, 'organisation')),
+        ...(logoUrl && { logoUrl }),
+        ...(website && { website }),
+    };
+};
+export const mapContact = (sourceContact, lang3) => {
+    const address = selectField(sourceContact, 'address');
+    const phone = selectField(sourceContact, 'phone');
+    return {
+        lastName: selectField(sourceContact, 'individual'),
+        organization: mapOrganization(sourceContact, lang3),
+        email: selectField(sourceContact, 'email'),
+        role: getRoleFromRoleCode(selectField(sourceContact, 'role')),
+        ...(address && { address }),
+        ...(phone && { phone }),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"atomic-operations.js","sourceRoot":"","sources":["../../../../../../../../libs/api/metadata-converter/src/lib/gn4/atomic-operations.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AAIvE,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,MAA8B,EAC9B,SAAiB,EACP,EAAE,CACZ,MAAM,KAAK,IAAI,IAAI,SAAS,IAAI,MAAM,CAAC,CAAC,CAAE,MAAM,CAAC,SAAS,CAAO,CAAC,CAAC,CAAC,IAAI,CAAA;AAE1E,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,MAA8B,EAC9B,GAAG,UAAoB,EACb,EAAE,CACZ,UAAU,CAAC,MAAM,CACf,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAClE,IAAI,CACL,CAAA;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAO,KAAQ,EAAE,QAAW,EAAS,EAAE,CACnE,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAA;AAEnC,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,MAA8B,EAC9B,KAAa,EACH,EAAE,CACZ,cAAc,CAAC,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAA;AAE5E,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,MAA8B,EAC9B,SAAiB,EACjB,KAAa,EACH,EAAE,CAAC,qBAAqB,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,KAAK,CAAC,CAAA;AAE3E,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAA;AAEhD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,EAAE,CACrC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;AAEzC,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,EAAE,CAClC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;AAE9D,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,KAAK,EACL,WAAmB,MAAM,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAC7C,EAAE;IACF,mGAAmG;IACnG,IAAI,KAAK,KAAK,EAAE,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAA;IAC/C,IAAI,GAAG,GAAG,KAAK,CAAA;IACf,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC;QAAE,GAAG,GAAG,WAAW,KAAK,EAAE,CAAA;IACnD,IAAI;QACF,OAAO,IAAI,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;KAC9B;IAAC,MAAM;QACN,OAAO,IAAI,CAAA;KACZ;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,MAA8B,EAAE,EAAE;IACxD,MAAM,IAAI,GAAG,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,CAAA;IAC5D,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;AACrD,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,aAAqC,EACrC,KAAa,EACC,EAAE;IAChB,MAAM,OAAO,GAAG,QAAQ,CAAC,WAAW,CAAS,aAAa,EAAE,SAAS,CAAC,CAAC,CAAA;IACvE,MAAM,OAAO,GAAG,QAAQ,CAAC,WAAW,CAAS,aAAa,EAAE,MAAM,CAAC,CAAC,CAAA;IACpE,OAAO;QACL,IAAI,EAAE,cAAc,CAClB,qBAAqB,CAAS,aAAa,EAAE,oBAAoB,EAAE,KAAK,CAAC,EACzE,WAAW,CAAS,aAAa,EAAE,cAAc,CAAC,CACnD;QACD,GAAG,CAAC,OAAO,IAAI,EAAE,OAAO,EAAE,CAAC;QAC3B,GAAG,CAAC,OAAO,IAAI,EAAE,OAAO,EAAE,CAAC;KAC5B,CAAA;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,aAAqC,EACrC,KAAa,EACD,EAAE;IACd,MAAM,OAAO,GAAG,WAAW,CAAS,aAAa,EAAE,SAAS,CAAC,CAAA;IAC7D,MAAM,KAAK,GAAG,WAAW,CAAS,aAAa,EAAE,OAAO,CAAC,CAAA;IACzD,OAAO;QACL,QAAQ,EAAE,WAAW,CAAS,aAAa,EAAE,YAAY,CAAC;QAC1D,YAAY,EAAE,eAAe,CAAC,aAAa,EAAE,KAAK,CAAC;QACnD,KAAK,EAAE,WAAW,CAAS,aAAa,EAAE,OAAO,CAAC;QAClD,IAAI,EAAE,mBAAmB,CAAC,WAAW,CAAS,aAAa,EAAE,MAAM,CAAC,CAAC;QACrE,GAAG,CAAC,OAAO,IAAI,EAAE,OAAO,EAAE,CAAC;QAC3B,GAAG,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE,CAAC;KACxB,CAAA;AACH,CAAC,CAAA","sourcesContent":["import { Individual, Organization } from '../../../../../../libs/common/domain/src/lib/record'\nimport { getRoleFromRoleCode } from '../iso19139/codelists/role.mapper'\n\nexport type SourceWithUnknownProps = { [key: string]: unknown }\n\nexport const selectField = <T>(\n  source: SourceWithUnknownProps,\n  fieldName: string\n): T | null =>\n  source !== null && fieldName in source ? (source[fieldName] as T) : null\n\nexport const selectFallbackFields = <T>(\n  source: SourceWithUnknownProps,\n  ...fieldNames: string[]\n): T | null =>\n  fieldNames.reduce<T>(\n    (prev, curr) => (prev === null ? selectField(source, curr) : prev),\n    null\n  )\n\nexport const selectFallback = <T, U>(field: T, fallback: U): T | U =>\n  field === null ? fallback : field\n\nexport const selectTranslatedValue = <T>(\n  source: SourceWithUnknownProps,\n  lang3: string\n): T | null =>\n  selectFallback(selectField(source, lang3), selectField(source, 'default'))\n\nexport const selectTranslatedField = <T>(\n  source: SourceWithUnknownProps,\n  fieldName: string,\n  lang3: string\n): T | null => selectTranslatedValue(selectField(source, fieldName), lang3)\n\nexport const toDate = (field) => new Date(field)\n\nexport const getFirstValue = (field) =>\n  Array.isArray(field) ? field[0] : field\n\nexport const getAsArray = (field) =>\n  Array.isArray(field) ? field : field !== null ? [field] : []\n\nexport const getAsUrl = (\n  field,\n  location: string = window.location.toString()\n) => {\n  // an empty string is not a valid url, even though it could be considered an empty path to the root\n  if (field === '' || field === null) return null\n  let url = field\n  if (field.match(/^www\\./)) url = `https://${field}`\n  try {\n    return new URL(url, location)\n  } catch {\n    return null\n  }\n}\n\nexport const mapLogo = (source: SourceWithUnknownProps) => {\n  const logo = selectFallbackFields(source, 'logoUrl', 'logo')\n  return logo ? getAsUrl(`/geonetwork${logo}`) : null\n}\n\nexport const mapOrganization = (\n  sourceContact: SourceWithUnknownProps,\n  lang3: string\n): Organization => {\n  const website = getAsUrl(selectField<string>(sourceContact, 'website'))\n  const logoUrl = getAsUrl(selectField<string>(sourceContact, 'logo'))\n  return {\n    name: selectFallback(\n      selectTranslatedField<string>(sourceContact, 'organisationObject', lang3),\n      selectField<string>(sourceContact, 'organisation')\n    ),\n    ...(logoUrl && { logoUrl }),\n    ...(website && { website }),\n  }\n}\n\nexport const mapContact = (\n  sourceContact: SourceWithUnknownProps,\n  lang3: string\n): Individual => {\n  const address = selectField<string>(sourceContact, 'address')\n  const phone = selectField<string>(sourceContact, 'phone')\n  return {\n    lastName: selectField<string>(sourceContact, 'individual'),\n    organization: mapOrganization(sourceContact, lang3),\n    email: selectField<string>(sourceContact, 'email'),\n    role: getRoleFromRoleCode(selectField<string>(sourceContact, 'role')),\n    ...(address && { address }),\n    ...(phone && { phone }),\n  }\n}\n"]}

package/esm2022/libs/api/metadata-converter/src/lib/gn4/gn4.field.mapper.mjs

@@ -0,0 +1,265 @@
+import { getAsArray, getAsUrl, getFirstValue, mapContact, selectFallback, selectFallbackFields, selectField, selectTranslatedField, selectTranslatedValue, toDate, } from './atomic-operations';
+import { MetadataUrlService } from './metadata-url.service';
+import { Injectable } from '@angular/core';
+import { getStatusFromStatusCode } from '../iso19139/codelists/status.mapper';
+import { getUpdateFrequencyFromFrequencyCode } from '../iso19139/codelists/update-frequency.mapper';
+import { matchProtocol } from '../common/distribution.mapper';
+import { LangService } from '../../../../../../libs/util/i18n/src';
+import * as i0 from "@angular/core";
+import * as i1 from "./metadata-url.service";
+import * as i2 from "../../../../../../libs/util/i18n/src";
+export class Gn4FieldMapper {
+    constructor(metadataUrlService, langService) {
+        this.metadataUrlService = metadataUrlService;
+        this.langService = langService;
+        this.lang3 = this.langService.gnLang;
+        this.fields = {
+            id: (output, source) => this.addExtra({ id: selectField(source, 'id') }, output),
+            uuid: (output, source) => {
+                const uuid = selectField(source, 'uuid');
+                const landingPage = getAsUrl(this.metadataUrlService.getUrl(uuid));
+                return { ...output, uniqueIdentifier: uuid, landingPage };
+            },
+            qualityScore: (output, source) => this.addExtra({ qualityScore: selectField(source, 'qualityScore') }, output),
+            resourceTitleObject: (output, source) => ({
+                ...output,
+                title: selectFallback(selectTranslatedField(source, 'resourceTitleObject', this.lang3), 'no title'),
+            }),
+            resourceAbstractObject: (output, source) => ({
+                ...output,
+                abstract: selectFallback(selectTranslatedField(source, 'resourceAbstractObject', this.lang3), 'no title'),
+            }),
+            overview: (output, source) => {
+                const firstOverview = getFirstValue(selectField(source, 'overview'));
+                const description = selectTranslatedValue(selectField(firstOverview, 'text'), this.lang3);
+                return {
+                    ...output,
+                    overviews: [
+                        {
+                            url: getAsUrl(selectFallbackFields(firstOverview, 'url', 'data')),
+                            ...(description ? { description } : {}),
+                        },
+                    ],
+                };
+            },
+            cl_topic: (output, source) => ({
+                ...output,
+                themes: [
+                    ...(output.themes || []),
+                    ...getAsArray(selectField(source, 'cl_topic')).map((topic) => selectTranslatedValue(topic, this.lang3)),
+                ],
+            }),
+            cl_status: (output, source) => ({
+                ...output,
+                status: getStatusFromStatusCode(selectField(getFirstValue(selectField(source, 'cl_status')), 'key')),
+            }),
+            cl_maintenanceAndUpdateFrequency: (output, source) => ({
+                ...output,
+                updateFrequency: getUpdateFrequencyFromFrequencyCode(selectField(getFirstValue(selectField(source, 'cl_maintenanceAndUpdateFrequency')), 'key')),
+            }),
+            creationDateForResource: (output, source) => ({
+                ...output,
+                datasetCreated: toDate(getFirstValue(selectField(source, 'creationDateForResource'))),
+            }),
+            createDate: (output, source) => ({
+                ...output,
+                recordCreated: toDate(selectField(source, 'createDate')),
+            }),
+            changeDate: (output, source) => ({
+                ...output,
+                recordUpdated: toDate(selectField(source, 'changeDate')),
+            }),
+            link: (output, source) => {
+                const rawLinks = getAsArray(selectField(source, 'link'));
+                const distributions = rawLinks
+                    .map((link) => this.mapLink(link))
+                    .filter((v) => v !== null);
+                return {
+                    ...output,
+                    distributions,
+                };
+            },
+            contact: (output, source) => ({
+                ...output,
+                contacts: [
+                    mapContact(getFirstValue(selectField(source, 'contact')), this.lang3),
+                ],
+            }),
+            contactForResource: (output, source) => ({
+                ...output,
+                contactsForResource: [
+                    ...('contactsForResource' in output &&
+                        Array.isArray(output.contactsForResource)
+                        ? output.contactsForResource
+                        : []),
+                    ...getAsArray(selectField(source, 'contactForResource')).map((contact) => mapContact(contact, this.lang3)),
+                ],
+            }),
+            sourceCatalogue: (output, source) => {
+                return this.addExtra({
+                    catalogUuid: selectFallback(selectField(source, 'sourceCatalogue'), 'no title'),
+                }, output);
+            },
+            tag: (output, source) => ({
+                ...output,
+                keywords: getAsArray(selectField(source, 'tag')).map((tag) => selectTranslatedValue(tag, this.lang3)),
+            }),
+            inspireTheme: (output, source) => ({
+                ...output,
+                themes: [
+                    ...(output.themes || []),
+                    ...getAsArray(selectField(source, 'inspireTheme_syn')),
+                ],
+            }),
+            MD_ConstraintsUseLimitationObject: (output, source) => this.constraintField('MD_ConstraintsUseLimitationObject', output, source),
+            MD_LegalConstraintsUseLimitationObject: (output, source) => this.constraintField('MD_LegalConstraintsUseLimitationObject', output, source),
+            MD_LegalConstraintsOtherConstraintsObject: (output, source) => this.constraintField('MD_LegalConstraintsOtherConstraintsObject', output, source),
+            MD_SecurityConstraintsUseLimitationObject: (output, source) => this.constraintField('MD_SecurityConstraintsUseLimitationObject', output, source),
+            licenseObject: (output, source) => ({
+                ...output,
+                licenses: getAsArray(selectField(source, 'licenseObject')).map((license) => {
+                    const link = getAsUrl(selectField(license, 'link'));
+                    return {
+                        text: selectTranslatedValue(license, this.lang3),
+                        ...(link ? { link } : {}),
+                    };
+                }),
+            }),
+            lineageObject: (output, source) => ({
+                ...output,
+                lineage: selectTranslatedField(source, 'lineageObject', this.lang3),
+            }),
+            mainLanguage: (output) => output,
+            userSavedCount: (output, source) => this.addExtra({
+                favoriteCount: parseInt(selectField(source, 'userSavedCount')),
+            }, output),
+            isOpenData: (output, source) => this.addExtra({
+                isOpenData: selectField(source, 'isOpenData') !== 'false',
+            }, output),
+            isPublishedToAll: (output, source) => this.addExtra({
+                isPublishedToAll: selectField(source, 'isPublishedToAll') !== 'false',
+            }, output),
+            userinfo: (output, source) => this.addExtra({
+                ownerInfo: selectField(source, 'userinfo'),
+            }, output),
+            cl_hierarchyLevel: (output, source) => {
+                const hierarchyLevel = selectField(getFirstValue(selectField(source, 'cl_hierarchyLevel')), 'key');
+                const kind = hierarchyLevel === 'service' ? 'service' : 'dataset';
+                return {
+                    ...output,
+                    kind,
+                };
+            },
+        };
+        this.genericField = (output) => output;
+        this.constraintField = (fieldName, output, source) => ({
+            ...output,
+            ...(fieldName.endsWith('UseLimitationObject')
+                ? {
+                    legalConstraints: fieldName === 'MD_LegalConstraintsUseLimitationObject'
+                        ? [
+                            ...(output.legalConstraints || []),
+                            ...selectField(source, fieldName).map((source) => selectTranslatedValue(source, this.lang3)),
+                        ]
+                        : output.legalConstraints || [],
+                    useLimitations: [
+                        ...(output.useLimitations || []),
+                        ...selectField(source, fieldName).map((source) => selectTranslatedValue(source, this.lang3)),
+                    ],
+                }
+                : {
+                    accessConstraints: [
+                        ...(output.accessConstraints || []),
+                        ...selectField(source, fieldName).map((field) => ({
+                            text: selectTranslatedValue(field, this.lang3),
+                            type: this.getConstraintsType(fieldName),
+                        })),
+                    ],
+                }),
+        });
+        this.mapLink = (sourceLink) => {
+            const url = getAsUrl(selectFallback(selectTranslatedField(sourceLink, 'urlObject', this.lang3), selectField(sourceLink, 'url')));
+            const name = selectFallback(selectTranslatedField(sourceLink, 'nameObject', this.lang3), selectField(sourceLink, 'name'));
+            const description = selectFallback(selectTranslatedField(sourceLink, 'descriptionObject', this.lang3), selectField(sourceLink, 'description'));
+            // no url: fail early
+            if (url === null) {
+                // TODO: collect errors at the record level?
+                console.warn('A link without valid URL was found', sourceLink);
+                return null;
+            }
+            const protocol = selectField(sourceLink, 'protocol');
+            const type = this.getLinkType(url.toString(), protocol);
+            const accessServiceProtocol = matchProtocol(protocol);
+            const mimeTypeMatches = protocol && protocol.match(/^WWW:DOWNLOAD:(.+\/.+)$/);
+            const mimeType = mimeTypeMatches && mimeTypeMatches[1];
+            const distribution = {
+                ...(name && { name }),
+                ...(description && { description }),
+            };
+            switch (type) {
+                case 'service':
+                    return {
+                        ...distribution,
+                        type,
+                        url: url,
+                        accessServiceProtocol,
+                    };
+                case 'link':
+                    return {
+                        ...distribution,
+                        type,
+                        url: url,
+                    };
+                case 'download':
+                    return {
+                        ...distribution,
+                        type,
+                        url: url,
+                        ...(mimeType && { mimeType }),
+                    };
+            }
+        };
+        this.addExtra = (value, output) => ({
+            ...output,
+            extras: { ...(output.extras || {}), ...value },
+        });
+    }
+    getConstraintsType(indexField) {
+        switch (indexField) {
+            case 'MD_LegalConstraintsUseLimitationObject':
+                return 'legal';
+            case 'MD_SecurityConstraintsUseLimitationObject':
+                return 'security';
+            case 'MD_ConstraintsUseLimitationObject':
+            default:
+                return 'other';
+        }
+    }
+    getMappingFn(fieldName) {
+        return fieldName in this.fields ? this.fields[fieldName] : this.genericField;
+    }
+    getLinkType(url, protocol) {
+        if (!protocol) {
+            return 'link';
+        }
+        if ((/^ESRI:REST/.test(protocol) && /FeatureServer/.test(url)) ||
+            /^OGC:WMS/.test(protocol) ||
+            /^OGC:WFS/.test(protocol) ||
+            /^OGC:WMTS/.test(protocol)) {
+            return 'service';
+        }
+        if (/^WWW:DOWNLOAD/.test(protocol)) {
+            return 'download';
+        }
+        return 'link';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: Gn4FieldMapper, deps: [{ token: i1.MetadataUrlService }, { token: i2.LangService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: Gn4FieldMapper, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: Gn4FieldMapper, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MetadataUrlService }, { type: i2.LangService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gn4.field.mapper.js","sourceRoot":"","sources":["../../../../../../../../libs/api/metadata-converter/src/lib/gn4/gn4.field.mapper.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  getAsArray,\n  getAsUrl,\n  getFirstValue,\n  mapContact,\n  selectFallback,\n  selectFallbackFields,\n  selectField,\n  selectTranslatedField,\n  selectTranslatedValue,\n  SourceWithUnknownProps,\n  toDate,\n} from './atomic-operations'\nimport { MetadataUrlService } from './metadata-url.service'\nimport { Injectable } from '@angular/core'\nimport { getStatusFromStatusCode } from '../iso19139/codelists/status.mapper'\nimport { getUpdateFrequencyFromFrequencyCode } from '../iso19139/codelists/update-frequency.mapper'\nimport {\n  AccessConstraintType,\n  CatalogRecord,\n  DatasetDistribution,\n  DatasetDistributionType,\n  DatasetDownloadDistribution,\n  DatasetServiceDistribution,\n  OnlineLinkResource,\n} from '../../../../../../libs/common/domain/src/lib/record'\nimport { matchProtocol } from '../common/distribution.mapper'\nimport { LangService } from '../../../../../../libs/util/i18n/src'\n\ntype ESResponseSource = SourceWithUnknownProps\n\ntype EsFieldMapperFn = (\n  output: Partial<CatalogRecord>,\n  source: ESResponseSource\n) => Partial<CatalogRecord>\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class Gn4FieldMapper {\n  constructor(\n    private metadataUrlService: MetadataUrlService,\n    private langService: LangService\n  ) {}\n\n  private lang3 = this.langService.gnLang\n\n  protected fields: Record<string, EsFieldMapperFn> = {\n    id: (output, source) =>\n      this.addExtra({ id: selectField(source, 'id') }, output),\n    uuid: (output, source) => {\n      const uuid = selectField<string>(source, 'uuid')\n      const landingPage = getAsUrl(this.metadataUrlService.getUrl(uuid))\n      return { ...output, uniqueIdentifier: uuid, landingPage }\n    },\n    qualityScore: (output, source) =>\n      this.addExtra(\n        { qualityScore: selectField(source, 'qualityScore') },\n        output\n      ),\n    resourceTitleObject: (output, source) => ({\n      ...output,\n      title: selectFallback(\n        selectTranslatedField(source, 'resourceTitleObject', this.lang3),\n        'no title'\n      ),\n    }),\n    resourceAbstractObject: (output, source) => ({\n      ...output,\n      abstract: selectFallback(\n        selectTranslatedField(source, 'resourceAbstractObject', this.lang3),\n        'no title'\n      ),\n    }),\n    overview: (output, source) => {\n      const firstOverview = getFirstValue(selectField(source, 'overview'))\n      const description = selectTranslatedValue<string>(\n        selectField(firstOverview, 'text'),\n        this.lang3\n      )\n      return {\n        ...output,\n        overviews: [\n          {\n            url: getAsUrl(selectFallbackFields(firstOverview, 'url', 'data')),\n            ...(description ? { description } : {}),\n          },\n        ],\n      }\n    },\n    cl_topic: (output, source) => ({\n      ...output,\n      themes: [\n        ...(output.themes || []),\n        ...getAsArray(\n          selectField<SourceWithUnknownProps[]>(source, 'cl_topic')\n        ).map((topic) => selectTranslatedValue<string>(topic, this.lang3)),\n      ],\n    }),\n    cl_status: (output, source) => ({\n      ...output,\n      status: getStatusFromStatusCode(\n        selectField(getFirstValue(selectField(source, 'cl_status')), 'key')\n      ),\n    }),\n    cl_maintenanceAndUpdateFrequency: (output, source) => ({\n      ...output,\n      updateFrequency: getUpdateFrequencyFromFrequencyCode(\n        selectField(\n          getFirstValue(\n            selectField(source, 'cl_maintenanceAndUpdateFrequency')\n          ),\n          'key'\n        )\n      ),\n    }),\n    creationDateForResource: (output, source) => ({\n      ...output,\n      datasetCreated: toDate(\n        getFirstValue(selectField<string>(source, 'creationDateForResource'))\n      ),\n    }),\n    createDate: (output, source) => ({\n      ...output,\n      recordCreated: toDate(selectField<string>(source, 'createDate')),\n    }),\n    changeDate: (output, source) => ({\n      ...output,\n      recordUpdated: toDate(selectField<string>(source, 'changeDate')),\n    }),\n    link: (output, source) => {\n      const rawLinks = getAsArray(\n        selectField<SourceWithUnknownProps[]>(source, 'link')\n      )\n      const distributions = rawLinks\n        .map((link) => this.mapLink(link))\n        .filter((v) => v !== null)\n      return {\n        ...output,\n        distributions,\n      }\n    },\n    contact: (output, source) => ({\n      ...output,\n      contacts: [\n        mapContact(getFirstValue(selectField(source, 'contact')), this.lang3),\n      ],\n    }),\n    contactForResource: (output, source) => ({\n      ...output,\n      contactsForResource: [\n        ...('contactsForResource' in output &&\n        Array.isArray(output.contactsForResource)\n          ? output.contactsForResource\n          : []),\n        ...getAsArray(selectField(source, 'contactForResource')).map(\n          (contact) => mapContact(contact, this.lang3)\n        ),\n      ],\n    }),\n    sourceCatalogue: (output, source) => {\n      return this.addExtra(\n        {\n          catalogUuid: selectFallback(\n            selectField(source, 'sourceCatalogue'),\n            'no title'\n          ),\n        },\n        output\n      )\n    },\n    tag: (output, source) => ({\n      ...output,\n      keywords: getAsArray(\n        selectField<SourceWithUnknownProps[]>(source, 'tag')\n      ).map((tag) => selectTranslatedValue<string>(tag, this.lang3)),\n    }),\n    inspireTheme: (output, source) => ({\n      ...output,\n      themes: [\n        ...(output.themes || []),\n        ...getAsArray(selectField(source, 'inspireTheme_syn')),\n      ],\n    }),\n    MD_ConstraintsUseLimitationObject: (output, source) =>\n      this.constraintField('MD_ConstraintsUseLimitationObject', output, source),\n    MD_LegalConstraintsUseLimitationObject: (output, source) =>\n      this.constraintField(\n        'MD_LegalConstraintsUseLimitationObject',\n        output,\n        source\n      ),\n    MD_LegalConstraintsOtherConstraintsObject: (output, source) =>\n      this.constraintField(\n        'MD_LegalConstraintsOtherConstraintsObject',\n        output,\n        source\n      ),\n    MD_SecurityConstraintsUseLimitationObject: (output, source) =>\n      this.constraintField(\n        'MD_SecurityConstraintsUseLimitationObject',\n        output,\n        source\n      ),\n    licenseObject: (output, source) => ({\n      ...output,\n      licenses: getAsArray(\n        selectField<SourceWithUnknownProps[]>(source, 'licenseObject')\n      ).map((license) => {\n        const link = getAsUrl(selectField(license, 'link'))\n        return {\n          text: selectTranslatedValue<string>(license, this.lang3),\n          ...(link ? { link } : {}),\n        }\n      }),\n    }),\n    lineageObject: (output, source) => ({\n      ...output,\n      lineage: selectTranslatedField(source, 'lineageObject', this.lang3),\n    }),\n    mainLanguage: (output) => output,\n    userSavedCount: (output, source) =>\n      this.addExtra(\n        {\n          favoriteCount: parseInt(selectField(source, 'userSavedCount')),\n        },\n        output\n      ),\n    isOpenData: (output, source) =>\n      this.addExtra(\n        {\n          isOpenData: selectField(source, 'isOpenData') !== 'false',\n        },\n        output\n      ),\n    isPublishedToAll: (output, source) =>\n      this.addExtra(\n        {\n          isPublishedToAll: selectField(source, 'isPublishedToAll') !== 'false',\n        },\n        output\n      ),\n    userinfo: (output, source) =>\n      this.addExtra(\n        {\n          ownerInfo: selectField(source, 'userinfo'),\n        },\n        output\n      ),\n    cl_hierarchyLevel: (output, source) => {\n      const hierarchyLevel = selectField(\n        getFirstValue(selectField(source, 'cl_hierarchyLevel')),\n        'key'\n      )\n      const kind = hierarchyLevel === 'service' ? 'service' : 'dataset'\n      return {\n        ...output,\n        kind,\n      }\n    },\n  }\n\n  private genericField = (output) => output\n\n  private constraintField = (fieldName: string, output, source) => ({\n    ...output,\n    ...(fieldName.endsWith('UseLimitationObject')\n      ? {\n          legalConstraints:\n            fieldName === 'MD_LegalConstraintsUseLimitationObject'\n              ? [\n                  ...(output.legalConstraints || []),\n                  ...selectField<SourceWithUnknownProps[]>(\n                    source,\n                    fieldName\n                  ).map((source: SourceWithUnknownProps) =>\n                    selectTranslatedValue(source, this.lang3)\n                  ),\n                ]\n              : output.legalConstraints || [],\n          useLimitations: [\n            ...(output.useLimitations || []),\n            ...selectField<SourceWithUnknownProps[]>(source, fieldName).map(\n              (source: SourceWithUnknownProps) =>\n                selectTranslatedValue(source, this.lang3)\n            ),\n          ],\n        }\n      : {\n          accessConstraints: [\n            ...(output.accessConstraints || []),\n            ...selectField<SourceWithUnknownProps[]>(source, fieldName).map(\n              (field) => ({\n                text: selectTranslatedValue(field, this.lang3),\n                type: this.getConstraintsType(fieldName),\n              })\n            ),\n          ],\n        }),\n  })\n\n  private getConstraintsType(indexField: string): AccessConstraintType {\n    switch (indexField) {\n      case 'MD_LegalConstraintsUseLimitationObject':\n        return 'legal'\n      case 'MD_SecurityConstraintsUseLimitationObject':\n        return 'security'\n      case 'MD_ConstraintsUseLimitationObject':\n      default:\n        return 'other'\n    }\n  }\n\n  getMappingFn(fieldName: string) {\n    return fieldName in this.fields ? this.fields[fieldName] : this.genericField\n  }\n\n  getLinkType(url: string, protocol?: string): DatasetDistributionType {\n    if (!protocol) {\n      return 'link'\n    }\n    if (\n      (/^ESRI:REST/.test(protocol) && /FeatureServer/.test(url)) ||\n      /^OGC:WMS/.test(protocol) ||\n      /^OGC:WFS/.test(protocol) ||\n      /^OGC:WMTS/.test(protocol)\n    ) {\n      return 'service'\n    }\n    if (/^WWW:DOWNLOAD/.test(protocol)) {\n      return 'download'\n    }\n    return 'link'\n  }\n\n  mapLink = (\n    sourceLink: SourceWithUnknownProps\n  ): DatasetDistribution | null => {\n    const url = getAsUrl(\n      selectFallback(\n        selectTranslatedField<string>(sourceLink, 'urlObject', this.lang3),\n        selectField<string>(sourceLink, 'url')\n      )\n    )\n    const name = selectFallback(\n      selectTranslatedField<string>(sourceLink, 'nameObject', this.lang3),\n      selectField<string>(sourceLink, 'name')\n    )\n    const description = selectFallback(\n      selectTranslatedField<string>(\n        sourceLink,\n        'descriptionObject',\n        this.lang3\n      ),\n      selectField<string>(sourceLink, 'description')\n    )\n    // no url: fail early\n    if (url === null) {\n      // TODO: collect errors at the record level?\n      console.warn('A link without valid URL was found', sourceLink)\n      return null\n    }\n\n    const protocol = selectField<string>(sourceLink, 'protocol')\n    const type = this.getLinkType(url.toString(), protocol)\n    const accessServiceProtocol = matchProtocol(protocol)\n    const mimeTypeMatches =\n      protocol && protocol.match(/^WWW:DOWNLOAD:(.+\\/.+)$/)\n    const mimeType = mimeTypeMatches && mimeTypeMatches[1]\n\n    const distribution = {\n      ...(name && { name }),\n      ...(description && { description }),\n    }\n    switch (type) {\n      case 'service':\n        return {\n          ...distribution,\n          type,\n          url: url,\n          accessServiceProtocol,\n        } as DatasetServiceDistribution\n      case 'link':\n        return {\n          ...distribution,\n          type,\n          url: url,\n        } as OnlineLinkResource\n      case 'download':\n        return {\n          ...distribution,\n          type,\n          url: url,\n          ...(mimeType && { mimeType }),\n        } as DatasetDownloadDistribution\n    }\n  }\n\n  private addExtra = (value: object, output: Partial<CatalogRecord>) => ({\n    ...output,\n    extras: { ...(output.extras || {}), ...value },\n  })\n}\n"]}