@deenruv/admin-ui 1.0.0

package/esm2022/core/providers/data-table/data-table-filter.mjs

@@ -0,0 +1,114 @@
+import { assertNever } from '@deenruv/common/lib/shared-utils';
+import dayjs from 'dayjs';
+export class DataTableFilter {
+    constructor(options, onActivate) {
+        this.options = options;
+        this.onActivate = onActivate;
+    }
+    get name() {
+        return this.options.name;
+    }
+    get type() {
+        return this.options.type;
+    }
+    get label() {
+        return this.options.label;
+    }
+    getFilterOperator(value) {
+        const type = this.options.type;
+        switch (type.kind) {
+            case 'boolean':
+                return {
+                    eq: !!value,
+                };
+            case 'dateRange': {
+                let dateOperators;
+                const mode = value.mode ?? 'relative';
+                if (mode === 'relative') {
+                    const relativeValue = value.relativeValue ?? 30;
+                    const relativeUnit = value.relativeUnit ?? 'day';
+                    dateOperators = {
+                        after: dayjs().subtract(relativeValue, relativeUnit).startOf('day').toISOString(),
+                    };
+                }
+                else {
+                    const start = value.start ?? undefined;
+                    const end = value.end ?? undefined;
+                    if (start && end) {
+                        dateOperators = {
+                            between: { start, end },
+                        };
+                    }
+                    else if (start) {
+                        dateOperators = {
+                            after: start,
+                        };
+                    }
+                    else {
+                        dateOperators = {
+                            before: end,
+                        };
+                    }
+                }
+                return dateOperators;
+            }
+            case 'number':
+                return {
+                    [value.operator]: Number(value.amount),
+                };
+            case 'select':
+                return { in: value };
+            case 'text':
+                return {
+                    [value.operator]: value.term,
+                };
+            case 'id':
+                return {
+                    [value.operator]: value.term,
+                };
+            case 'custom': {
+                return value;
+            }
+            default:
+                assertNever(type);
+        }
+    }
+    toFilterInput(value) {
+        if (this.options.toFilterInput) {
+            return this.options.toFilterInput(value);
+        }
+        if (this.options.filterField) {
+            return { [this.options.filterField]: this.getFilterOperator(value) };
+        }
+        else {
+            throw new Error(`Either "filterField" or "toFilterInput" must be provided (for filter "${this.name}"))`);
+        }
+    }
+    activate(value) {
+        if (this.onActivate) {
+            this.onActivate(this, value);
+        }
+    }
+    isId() {
+        return this.type.kind === 'id';
+    }
+    isText() {
+        return this.type.kind === 'text';
+    }
+    isNumber() {
+        return this.type.kind === 'number';
+    }
+    isBoolean() {
+        return this.type.kind === 'boolean';
+    }
+    isSelect() {
+        return this.type.kind === 'select';
+    }
+    isDateRange() {
+        return this.type.kind === 'dateRange';
+    }
+    isCustom() {
+        return this.type.kind === 'custom';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-table-filter.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/data-table/data-table-filter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Type as ComponentType } from '@angular/core';\nimport { LocalizedString } from '@deenruv/common/lib/generated-types';\nimport { assertNever } from '@deenruv/common/lib/shared-utils';\nimport dayjs from 'dayjs';\nimport { FormInputComponent } from '../../common/component-registry-types';\nimport {\n    BooleanOperators,\n    DateOperators,\n    IdOperators,\n    NumberOperators,\n    StringOperators,\n} from '../../common/generated-types';\n\nexport interface DataTableFilterIDType {\n    kind: 'id';\n}\n\nexport interface DataTableFilterTextType {\n    kind: 'text';\n    placeholder?: string;\n}\n\nexport interface DataTableFilterSelectType {\n    kind: 'select';\n    options: Array<{ value: any; label: string }>;\n}\n\nexport interface DataTableFilterBooleanType {\n    kind: 'boolean';\n}\n\nexport interface DataTableFilterNumberType {\n    kind: 'number';\n    inputType?: 'number' | 'currency';\n}\n\nexport interface DataTableFilterDateRangeType {\n    kind: 'dateRange';\n}\n\nexport interface DataTableFilterCustomType {\n    kind: 'custom';\n    component: ComponentType<FormInputComponent>;\n    serializeValue: (value: any) => string;\n    deserializeValue: (serialized: string) => any;\n    getLabel(value: any): string | Promise<string>;\n}\n\nexport type KindValueMap = {\n    id: {\n        raw: {\n            operator: keyof IdOperators;\n            term: string;\n        };\n        input: IdOperators;\n    };\n    text: {\n        raw: {\n            operator: keyof StringOperators;\n            term: string;\n        };\n        input: StringOperators;\n    };\n    select: { raw: string[]; input: StringOperators };\n    boolean: { raw: boolean; input: BooleanOperators };\n    dateRange: {\n        raw: {\n            mode: 'relative' | 'range';\n            relativeValue: number;\n            relativeUnit: 'day' | 'month' | 'year';\n            start?: string;\n            end?: string;\n        };\n        input: DateOperators;\n    };\n    number: { raw: { operator: keyof NumberOperators; amount: number }; input: NumberOperators };\n    custom: { raw: any; input: any };\n};\nexport type DataTableFilterType =\n    | DataTableFilterIDType\n    | DataTableFilterTextType\n    | DataTableFilterSelectType\n    | DataTableFilterBooleanType\n    | DataTableFilterDateRangeType\n    | DataTableFilterNumberType\n    | DataTableFilterCustomType;\n\nexport interface DataTableFilterOptions<\n    FilterInput extends Record<string, any> = any,\n    Type extends DataTableFilterType = DataTableFilterType,\n> {\n    readonly name: string;\n    readonly type: Type;\n    readonly label: string | LocalizedString[];\n    readonly filterField?: keyof FilterInput;\n    readonly toFilterInput?: (value: DataTableFilterValue<Type>) => Partial<FilterInput>;\n}\n\nexport type DataTableFilterValue<Type extends DataTableFilterType> = KindValueMap[Type['kind']]['raw'];\nexport type DataTableFilterOperator<Type extends DataTableFilterType> = KindValueMap[Type['kind']]['input'];\n\nexport class DataTableFilter<\n    FilterInput extends Record<string, any> = any,\n    Type extends DataTableFilterType = DataTableFilterType,\n> {\n    constructor(\n        private readonly options: DataTableFilterOptions<FilterInput, Type>,\n        private onActivate?: (\n            filter: DataTableFilter<FilterInput, Type>,\n            value: DataTableFilterValue<Type> | undefined,\n        ) => void,\n    ) {}\n\n    get name(): string {\n        return this.options.name;\n    }\n\n    get type(): Type {\n        return this.options.type;\n    }\n\n    get label(): string | LocalizedString[] {\n        return this.options.label;\n    }\n\n    getFilterOperator(value: any): DataTableFilterOperator<Type> {\n        const type = this.options.type;\n        switch (type.kind) {\n            case 'boolean':\n                return {\n                    eq: !!value,\n                };\n            case 'dateRange': {\n                let dateOperators: DateOperators;\n                const mode = value.mode ?? 'relative';\n                if (mode === 'relative') {\n                    const relativeValue = value.relativeValue ?? 30;\n                    const relativeUnit = value.relativeUnit ?? 'day';\n                    dateOperators = {\n                        after: dayjs().subtract(relativeValue, relativeUnit).startOf('day').toISOString(),\n                    };\n                } else {\n                    const start = value.start ?? undefined;\n                    const end = value.end ?? undefined;\n                    if (start && end) {\n                        dateOperators = {\n                            between: { start, end },\n                        };\n                    } else if (start) {\n                        dateOperators = {\n                            after: start,\n                        };\n                    } else {\n                        dateOperators = {\n                            before: end,\n                        };\n                    }\n                }\n                return dateOperators;\n            }\n            case 'number':\n                return {\n                    [value.operator]: Number(value.amount),\n                };\n\n            case 'select':\n                return { in: value };\n            case 'text':\n                return {\n                    [value.operator]: value.term,\n                };\n            case 'id':\n                return {\n                    [value.operator]: value.term,\n                };\n            case 'custom': {\n                return value;\n            }\n            default:\n                assertNever(type);\n        }\n    }\n\n    toFilterInput(value: DataTableFilterValue<Type>): Partial<FilterInput> {\n        if (this.options.toFilterInput) {\n            return this.options.toFilterInput(value);\n        }\n        if (this.options.filterField) {\n            return { [this.options.filterField]: this.getFilterOperator(value) } as Partial<FilterInput>;\n        } else {\n            throw new Error(\n                `Either \"filterField\" or \"toFilterInput\" must be provided (for filter \"${this.name}\"))`,\n            );\n        }\n    }\n\n    activate(value: DataTableFilterValue<Type>) {\n        if (this.onActivate) {\n            this.onActivate(this, value);\n        }\n    }\n\n    isId(): this is DataTableFilter<FilterInput, DataTableFilterIDType> {\n        return this.type.kind === 'id';\n    }\n\n    isText(): this is DataTableFilter<FilterInput, DataTableFilterTextType> {\n        return this.type.kind === 'text';\n    }\n\n    isNumber(): this is DataTableFilter<FilterInput, DataTableFilterNumberType> {\n        return this.type.kind === 'number';\n    }\n\n    isBoolean(): this is DataTableFilter<FilterInput, DataTableFilterBooleanType> {\n        return this.type.kind === 'boolean';\n    }\n\n    isSelect(): this is DataTableFilter<FilterInput, DataTableFilterSelectType> {\n        return this.type.kind === 'select';\n    }\n\n    isDateRange(): this is DataTableFilter<FilterInput, DataTableFilterDateRangeType> {\n        return this.type.kind === 'dateRange';\n    }\n\n    isCustom(): this is DataTableFilter<FilterInput, DataTableFilterCustomType> {\n        return this.type.kind === 'custom';\n    }\n}\n"]}

package/esm2022/core/providers/data-table/data-table-sort-collection.mjs

@@ -0,0 +1,115 @@
+import { assertNever } from '@deenruv/common/lib/shared-utils';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { DataTableSort } from './data-table-sort';
+export class DataTableSortCollection {
+    #sorts;
+    #valueChanges$;
+    #connectedToRouter;
+    #sortQueryParamName;
+    #defaultSort;
+    constructor(router) {
+        this.router = router;
+        this.#sorts = [];
+        this.#valueChanges$ = new Subject();
+        this.#connectedToRouter = false;
+        this.valueChanges = this.#valueChanges$.asObservable();
+        this.#sortQueryParamName = 'sort';
+        this.destroy$ = new Subject();
+    }
+    get length() {
+        return this.#sorts.length;
+    }
+    destroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    addSort(config) {
+        if (this.#connectedToRouter) {
+            throw new Error('Cannot add sort after connecting to router. Make sure to call addSort() before connectToRoute()');
+        }
+        this.#sorts.push(new DataTableSort(config, () => this.onSetValue()));
+        return this;
+    }
+    addSorts(configs) {
+        for (const config of configs) {
+            this.addSort(config);
+        }
+        return this;
+    }
+    addCustomFieldSorts(customFields) {
+        for (const config of customFields) {
+            const type = config.type;
+            if (config.list) {
+                continue;
+            }
+            switch (type) {
+                case 'string':
+                case 'localeString':
+                case 'boolean':
+                case 'int':
+                case 'float':
+                case 'datetime':
+                case 'localeText':
+                case 'text':
+                    this.addSort({ name: config.name });
+                    break;
+                case 'relation':
+                    // Cannot sort relations
+                    break;
+                default:
+                    assertNever(type);
+            }
+        }
+        return this;
+    }
+    defaultSort(name, sortOrder) {
+        this.#defaultSort = { name, sortOrder };
+        return this;
+    }
+    get(name) {
+        return this.#sorts.find(s => s.name === name);
+    }
+    connectToRoute(route) {
+        this.valueChanges.pipe(takeUntil(this.destroy$)).subscribe(() => {
+            this.router.navigate(['./'], {
+                queryParams: { [this.#sortQueryParamName]: this.serialize() },
+                relativeTo: route,
+                queryParamsHandling: 'merge',
+            });
+        });
+        const filterQueryParams = (route.snapshot.queryParamMap.get(this.#sortQueryParamName) ?? '')
+            .split(';')
+            .map(value => value.split(':'))
+            .map(([name, value]) => ({ name, value }));
+        for (const { name, value } of filterQueryParams) {
+            const sort = this.get(name);
+            if (sort) {
+                sort.setSortOrder(value);
+            }
+        }
+        this.#connectedToRouter = true;
+        return this;
+    }
+    createSortInput() {
+        const activeSorts = this.#sorts.filter(s => s.sortOrder !== undefined);
+        let sortInput = {};
+        if (activeSorts.length === 0 && this.#defaultSort) {
+            return { [this.#defaultSort.name]: this.#defaultSort.sortOrder };
+        }
+        for (const sort of activeSorts) {
+            sortInput = { ...sortInput, [sort.name]: sort.sortOrder };
+        }
+        return sortInput;
+    }
+    serialize() {
+        const activeSorts = this.#sorts.filter(s => s.sortOrder !== undefined);
+        return activeSorts.map(s => `${s.name}:${s.sortOrder}`).join(';');
+    }
+    onSetValue() {
+        this.#valueChanges$.next(this.#sorts
+            .filter(f => f.sortOrder !== undefined)
+            .map(s => ({ name: s.name, sortOrder: s.sortOrder })));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-table-sort-collection.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/data-table/data-table-sort-collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActivatedRoute, Router } from '@angular/router';\nimport { CustomFieldType } from '@deenruv/common/lib/shared-types';\nimport { assertNever } from '@deenruv/common/lib/shared-utils';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { CustomFieldConfig } from '../../common/generated-types';\nimport { DataTableSort, DataTableSortOptions, DataTableSortOrder } from './data-table-sort';\n\nexport class DataTableSortCollection<\n    SortInput extends Record<string, 'ASC' | 'DESC'>,\n    Names extends [...Array<keyof SortInput>] = [],\n> {\n    readonly #sorts: Array<DataTableSort<SortInput>> = [];\n    #valueChanges$ = new Subject<Array<{ name: string; sortOrder: DataTableSortOrder | undefined }>>();\n    #connectedToRouter = false;\n    valueChanges = this.#valueChanges$.asObservable();\n    readonly #sortQueryParamName = 'sort';\n    #defaultSort: { name: keyof SortInput; sortOrder: DataTableSortOrder } | undefined;\n    private readonly destroy$ = new Subject<void>();\n\n    constructor(private router: Router) {}\n\n    get length(): number {\n        return this.#sorts.length;\n    }\n\n    destroy() {\n        this.destroy$.next();\n        this.destroy$.complete();\n    }\n\n    addSort<Name extends keyof SortInput>(\n        config: DataTableSortOptions<SortInput, Name>,\n    ): DataTableSortCollection<SortInput, [...Names, Name]> {\n        if (this.#connectedToRouter) {\n            throw new Error(\n                'Cannot add sort after connecting to router. Make sure to call addSort() before connectToRoute()',\n            );\n        }\n        this.#sorts.push(new DataTableSort<SortInput>(config, () => this.onSetValue()));\n        return this as unknown as DataTableSortCollection<SortInput, [...Names, Name]>;\n    }\n\n    addSorts<Name extends keyof SortInput>(\n        configs: Array<DataTableSortOptions<SortInput, Name>>,\n    ): DataTableSortCollection<SortInput, [...Names, Name]> {\n        for (const config of configs) {\n            this.addSort(config);\n        }\n        return this as unknown as DataTableSortCollection<SortInput, [...Names, Name]>;\n    }\n\n    addCustomFieldSorts(customFields: CustomFieldConfig[]) {\n        for (const config of customFields) {\n            const type = config.type as CustomFieldType;\n            if (config.list) {\n                continue;\n            }\n            switch (type) {\n                case 'string':\n                case 'localeString':\n                case 'boolean':\n                case 'int':\n                case 'float':\n                case 'datetime':\n                case 'localeText':\n                case 'text':\n                    this.addSort({ name: config.name });\n                    break;\n                case 'relation':\n                    // Cannot sort relations\n                    break;\n                default:\n                    assertNever(type);\n            }\n        }\n        return this;\n    }\n\n    defaultSort(name: keyof SortInput, sortOrder: DataTableSortOrder) {\n        this.#defaultSort = { name, sortOrder };\n        return this;\n    }\n\n    get(name: Names[number]): DataTableSort<SortInput> | undefined {\n        return this.#sorts.find(s => s.name === name);\n    }\n\n    connectToRoute(route: ActivatedRoute) {\n        this.valueChanges.pipe(takeUntil(this.destroy$)).subscribe(() => {\n            this.router.navigate(['./'], {\n                queryParams: { [this.#sortQueryParamName]: this.serialize() },\n                relativeTo: route,\n                queryParamsHandling: 'merge',\n            });\n        });\n        const filterQueryParams = (route.snapshot.queryParamMap.get(this.#sortQueryParamName) ?? '')\n            .split(';')\n            .map(value => value.split(':'))\n            .map(([name, value]) => ({ name, value }));\n        for (const { name, value } of filterQueryParams) {\n            const sort = this.get(name);\n            if (sort) {\n                sort.setSortOrder(value as any);\n            }\n        }\n        this.#connectedToRouter = true;\n        return this;\n    }\n\n    createSortInput(): SortInput {\n        const activeSorts = this.#sorts.filter(s => s.sortOrder !== undefined);\n        let sortInput = {} as SortInput;\n        if (activeSorts.length === 0 && this.#defaultSort) {\n            return { [this.#defaultSort.name]: this.#defaultSort.sortOrder } as SortInput;\n        }\n        for (const sort of activeSorts) {\n            sortInput = { ...sortInput, [sort.name]: sort.sortOrder };\n        }\n        return sortInput;\n    }\n\n    private serialize(): string {\n        const activeSorts = this.#sorts.filter(s => s.sortOrder !== undefined);\n        return activeSorts.map(s => `${s.name as string}:${s.sortOrder}`).join(';');\n    }\n\n    private onSetValue() {\n        this.#valueChanges$.next(\n            this.#sorts\n                .filter(f => f.sortOrder !== undefined)\n                .map(s => ({ name: s.name as any, sortOrder: s.sortOrder })),\n        );\n    }\n}\n"]}

package/esm2022/core/providers/data-table/data-table-sort.mjs

@@ -0,0 +1,34 @@
+export class DataTableSort {
+    constructor(options, onSetValue) {
+        this.options = options;
+        this.onSetValue = onSetValue;
+    }
+    #sortOrder;
+    get sortOrder() {
+        return this.#sortOrder;
+    }
+    get name() {
+        return this.options.name;
+    }
+    toggleSortOrder() {
+        if (this.#sortOrder === undefined) {
+            this.#sortOrder = 'ASC';
+        }
+        else if (this.#sortOrder === 'ASC') {
+            this.#sortOrder = 'DESC';
+        }
+        else {
+            this.#sortOrder = undefined;
+        }
+        if (this.onSetValue) {
+            this.onSetValue(this.name, this.#sortOrder);
+        }
+    }
+    setSortOrder(sortOrder) {
+        this.#sortOrder = sortOrder;
+        if (this.onSetValue) {
+            this.onSetValue(this.name, this.#sortOrder);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/providers/guard/auth.guard.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { tap } from 'rxjs/operators';
+import { getAppConfig } from '../../app.config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../auth/auth.service";
+/**
+ * This guard prevents unauthorized users from accessing any routes which require
+ * authorization.
+ */
+export class AuthGuard {
+    constructor(router, authService) {
+        this.router = router;
+        this.authService = authService;
+        this.externalLoginUrl = getAppConfig().loginUrl;
+    }
+    canActivate(route) {
+        return this.authService.checkAuthenticatedStatus().pipe(tap(authenticated => {
+            if (!authenticated) {
+                if (this.externalLoginUrl) {
+                    window.location.href = this.externalLoginUrl;
+                }
+                else {
+                    this.router.navigate(['/login']);
+                }
+            }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthGuard, deps: [{ token: i1.Router }, { token: i2.AuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthGuard, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.AuthService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/providers/health-check/health-check.service.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { merge, of, Subject, timer } from 'rxjs';
+import { catchError, map, shareReplay, switchMap, throttleTime } from 'rxjs/operators';
+import { getServerLocation } from '../../data/utils/get-server-location';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class HealthCheckService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.pollingDelayMs = 60 * 1000;
+        this._refresh = new Subject();
+        this.healthCheckEndpoint = getServerLocation() + '/health';
+        const refresh$ = this._refresh.pipe(throttleTime(1000));
+        const result$ = merge(timer(0, this.pollingDelayMs), refresh$).pipe(switchMap(() => this.checkHealth()), shareReplay(1));
+        this.status$ = result$.pipe(map(res => res.status));
+        this.details$ = result$.pipe(map(res => Object.keys(res.details).map(key => ({ key, result: res.details[key] }))));
+        this.lastCheck$ = result$.pipe(map(res => res.lastChecked));
+    }
+    refresh() {
+        this._refresh.next();
+    }
+    checkHealth() {
+        return this.httpClient.get(this.healthCheckEndpoint).pipe(catchError(err => of(err.error)), map(res => ({ ...res, lastChecked: new Date() })));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HealthCheckService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HealthCheckService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HealthCheckService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/providers/i18n/custom-http-loader.mjs

@@ -0,0 +1,39 @@
+import { map } from 'rxjs/operators';
+/**
+ * A loader for ngx-translate which extends the HttpLoader functionality by stripping out any
+ * values which are empty strings. This means that during development, translation keys which have
+ * been extracted but not yet defined will fall back to the raw key text rather than displaying nothing.
+ *
+ * Originally from https://github.com/ngx-translate/core/issues/662#issuecomment-377010232
+ */
+export class CustomHttpTranslationLoader {
+    constructor(http, prefix = '/assets/i18n/', suffix = '.json') {
+        this.http = http;
+        this.prefix = prefix;
+        this.suffix = suffix;
+    }
+    getTranslation(lang) {
+        return this.http
+            .get(`${this.prefix}${lang}${this.suffix}`)
+            .pipe(map((res) => this.process(res)));
+    }
+    process(object) {
+        const newObject = {};
+        for (const key in object) {
+            if (object.hasOwnProperty(key)) {
+                const value = object[key];
+                if (typeof value !== 'string') {
+                    newObject[key] = this.process(value);
+                }
+                else if (typeof value === 'string' && value === '') {
+                    // do not copy empty strings
+                }
+                else {
+                    newObject[key] = object[key];
+                }
+            }
+        }
+        return newObject;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/providers/i18n/custom-message-format-compiler.mjs

@@ -0,0 +1,31 @@
+/* eslint-disable no-console */
+import { Injectable } from '@angular/core';
+import { TranslateMessageFormatCompiler, } from 'ngx-translate-messageformat-compiler';
+import * as i0 from "@angular/core";
+/**
+ * Work-around for Angular 9 compat.
+ * See https://github.com/lephyrus/ngx-translate-messageformat-compiler/issues/53#issuecomment-583677994
+ *
+ * Also logs errors which would otherwise get swallowed by ngx-translate. This is important
+ * because it is quite easy to make errors in messageformat syntax, and without clear
+ * error messages it's very hard to debug.
+ */
+export class InjectableTranslateMessageFormatCompiler extends TranslateMessageFormatCompiler {
+    compileTranslations(value, lang) {
+        try {
+            return super.compileTranslations(value, lang);
+        }
+        catch (e) {
+            console.error(`There was an error with the ${lang} translations:`);
+            console.log(e);
+            console.log(`Check the messageformat docs: https://messageformat.github.io/messageformat/page-guide`);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InjectableTranslateMessageFormatCompiler, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InjectableTranslateMessageFormatCompiler, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InjectableTranslateMessageFormatCompiler, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLW1lc3NhZ2UtZm9ybWF0LWNvbXBpbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb3JlL3NyYy9wcm92aWRlcnMvaTE4bi9jdXN0b20tbWVzc2FnZS1mb3JtYXQtY29tcGlsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0JBQStCO0FBQy9CLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUNILDhCQUE4QixHQUVqQyxNQUFNLHNDQUFzQyxDQUFDOztBQUU5Qzs7Ozs7OztHQU9HO0FBRUgsTUFBTSxPQUFPLHdDQUF5QyxTQUFRLDhCQUE4QjtJQUN4RixtQkFBbUIsQ0FBQyxLQUFVLEVBQUUsSUFBWTtRQUN4QyxJQUFJLENBQUM7WUFDRCxPQUFPLEtBQUssQ0FBQyxtQkFBbUIsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFDbEQsQ0FBQztRQUFDLE9BQU8sQ0FBTSxFQUFFLENBQUM7WUFDZCxPQUFPLENBQUMsS0FBSyxDQUFDLCtCQUErQixJQUFJLGdCQUFnQixDQUFDLENBQUM7WUFDbkUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNmLE9BQU8sQ0FBQyxHQUFHLENBQ1Asd0ZBQXdGLENBQzNGLENBQUM7UUFDTixDQUFDO0lBQ0wsQ0FBQzsrR0FYUSx3Q0FBd0M7bUhBQXhDLHdDQUF3QyxjQUQzQixNQUFNOzs0RkFDbkIsd0NBQXdDO2tCQURwRCxVQUFVO21CQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIG5vLWNvbnNvbGUgKi9cbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gICAgVHJhbnNsYXRlTWVzc2FnZUZvcm1hdENvbXBpbGVyLFxuICAgIFRyYW5zbGF0ZU1lc3NhZ2VGb3JtYXREZWJ1Z0NvbXBpbGVyLFxufSBmcm9tICduZ3gtdHJhbnNsYXRlLW1lc3NhZ2Vmb3JtYXQtY29tcGlsZXInO1xuXG4vKipcbiAqIFdvcmstYXJvdW5kIGZvciBBbmd1bGFyIDkgY29tcGF0LlxuICogU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9sZXBoeXJ1cy9uZ3gtdHJhbnNsYXRlLW1lc3NhZ2Vmb3JtYXQtY29tcGlsZXIvaXNzdWVzLzUzI2lzc3VlY29tbWVudC01ODM2Nzc5OTRcbiAqXG4gKiBBbHNvIGxvZ3MgZXJyb3JzIHdoaWNoIHdvdWxkIG90aGVyd2lzZSBnZXQgc3dhbGxvd2VkIGJ5IG5neC10cmFuc2xhdGUuIFRoaXMgaXMgaW1wb3J0YW50XG4gKiBiZWNhdXNlIGl0IGlzIHF1aXRlIGVhc3kgdG8gbWFrZSBlcnJvcnMgaW4gbWVzc2FnZWZvcm1hdCBzeW50YXgsIGFuZCB3aXRob3V0IGNsZWFyXG4gKiBlcnJvciBtZXNzYWdlcyBpdCdzIHZlcnkgaGFyZCB0byBkZWJ1Zy5cbiAqL1xuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBJbmplY3RhYmxlVHJhbnNsYXRlTWVzc2FnZUZvcm1hdENvbXBpbGVyIGV4dGVuZHMgVHJhbnNsYXRlTWVzc2FnZUZvcm1hdENvbXBpbGVyIHtcbiAgICBjb21waWxlVHJhbnNsYXRpb25zKHZhbHVlOiBhbnksIGxhbmc6IHN0cmluZyk6IGFueSB7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgICByZXR1cm4gc3VwZXIuY29tcGlsZVRyYW5zbGF0aW9ucyh2YWx1ZSwgbGFuZyk7XG4gICAgICAgIH0gY2F0Y2ggKGU6IGFueSkge1xuICAgICAgICAgICAgY29uc29sZS5lcnJvcihgVGhlcmUgd2FzIGFuIGVycm9yIHdpdGggdGhlICR7bGFuZ30gdHJhbnNsYXRpb25zOmApO1xuICAgICAgICAgICAgY29uc29sZS5sb2coZSk7XG4gICAgICAgICAgICBjb25zb2xlLmxvZyhcbiAgICAgICAgICAgICAgICBgQ2hlY2sgdGhlIG1lc3NhZ2Vmb3JtYXQgZG9jczogaHR0cHM6Ly9tZXNzYWdlZm9ybWF0LmdpdGh1Yi5pby9tZXNzYWdlZm9ybWF0L3BhZ2UtZ3VpZGVgLFxuICAgICAgICAgICAgKTtcbiAgICAgICAgfVxuICAgIH1cbn1cbiJdfQ==

package/esm2022/core/providers/i18n/i18n.service.mjs

@@ -0,0 +1,78 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { LanguageCode } from '../../common/generated-types';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+/** @dynamic */
+export class I18nService {
+    get availableLanguages() {
+        return [...this._availableLanguages];
+    }
+    get availableLocales() {
+        return [...this._availableLocales];
+    }
+    constructor(ngxTranslate, document) {
+        this.ngxTranslate = ngxTranslate;
+        this.document = document;
+        this._availableLocales = [];
+        this._availableLanguages = [];
+    }
+    /**
+     * Set the default language
+     */
+    setDefaultLanguage(languageCode) {
+        this.ngxTranslate.setDefaultLang(languageCode);
+    }
+    /**
+     * Set the UI language
+     */
+    setLanguage(language) {
+        this.ngxTranslate.use(language);
+        if (this.document?.documentElement) {
+            this.document.documentElement.lang = language;
+        }
+    }
+    /**
+     * Set the available UI languages
+     */
+    setAvailableLanguages(languages) {
+        this._availableLanguages = languages;
+    }
+    /**
+     * Set the available UI locales
+     */
+    setAvailableLocales(locales) {
+        this._availableLocales = locales;
+    }
+    /**
+     * Translate the given key.
+     */
+    translate(key, params) {
+        return this.ngxTranslate.instant(key, params);
+    }
+    /**
+     * Returns true if the given language code is a right-to-left language.
+     */
+    isRTL(languageCode) {
+        const rtlLanguageCodes = [
+            LanguageCode.ar,
+            LanguageCode.he,
+            LanguageCode.fa,
+            LanguageCode.ur,
+            LanguageCode.ps,
+        ];
+        return rtlLanguageCodes.includes(languageCode);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: I18nService, deps: [{ token: i1.TranslateService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: I18nService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: I18nService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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