@deenruv/admin-ui 1.0.0

package/esm2022/core/core.module.mjs

@@ -0,0 +1,165 @@
+import { PlatformLocation } from '@angular/common';
+import { HttpClient } from '@angular/common/http';
+import { NgModule } from '@angular/core';
+import { BrowserModule, Title } from '@angular/platform-browser';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
+import { TranslateCompiler, TranslateLoader, TranslateModule } from '@ngx-translate/core';
+import { interval } from 'rxjs';
+import { getAppConfig } from './app.config';
+import { getDefaultUiLanguage, getDefaultUiLocale } from './common/utilities/get-default-ui-language';
+import { AlertsComponent } from './components/alerts/alerts.component';
+import { AppShellComponent } from './components/app-shell/app-shell.component';
+import { BaseNavComponent } from './components/base-nav/base-nav.component';
+import { BreadcrumbComponent } from './components/breadcrumb/breadcrumb.component';
+import { ChannelSwitcherComponent } from './components/channel-switcher/channel-switcher.component';
+import { MainNavComponent } from './components/main-nav/main-nav.component';
+import { NotificationComponent } from './components/notification/notification.component';
+import { OverlayHostComponent } from './components/overlay-host/overlay-host.component';
+import { SettingsNavComponent } from './components/settings-nav/settings-nav.component';
+import { ThemeSwitcherComponent } from './components/theme-switcher/theme-switcher.component';
+import { UiLanguageSwitcherDialogComponent } from './components/ui-language-switcher-dialog/ui-language-switcher-dialog.component';
+import { UserMenuComponent } from './components/user-menu/user-menu.component';
+import { DataModule } from './data/data.module';
+import { CustomHttpTranslationLoader } from './providers/i18n/custom-http-loader';
+import { InjectableTranslateMessageFormatCompiler } from './providers/i18n/custom-message-format-compiler';
+import { Permission } from './public_api';
+import { registerDefaultFormInputs } from './shared/dynamic-form-inputs/default-form-inputs';
+import { SharedModule } from './shared/shared.module';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/i18n/i18n.service";
+import * as i2 from "./providers/local-storage/local-storage.service";
+import * as i3 from "@angular/platform-browser";
+import * as i4 from "./providers/alerts/alerts.service";
+import * as i5 from "@ngx-translate/core";
+export class CoreModule {
+    constructor(i18nService, localStorageService, titleService, alertsService) {
+        this.i18nService = i18nService;
+        this.localStorageService = localStorageService;
+        this.titleService = titleService;
+        this.alertsService = alertsService;
+        this.initUiLanguagesAndLocales();
+        this.initUiTitle();
+        this.initAlerts();
+    }
+    initUiLanguagesAndLocales() {
+        const defaultLanguage = getDefaultUiLanguage();
+        const defaultLocale = getDefaultUiLocale();
+        const lastLanguage = this.localStorageService.get('uiLanguageCode');
+        const availableLanguages = getAppConfig().availableLanguages;
+        const availableLocales = getAppConfig().availableLocales ?? [defaultLocale];
+        if (!!defaultLanguage && !availableLanguages.includes(defaultLanguage)) {
+            throw new Error(`The defaultLanguage "${defaultLanguage}" must be one of the availableLanguages [${availableLanguages
+                .map(l => `"${l}"`)
+                .join(', ')}]`);
+        }
+        if (!!defaultLocale && !availableLocales.includes(defaultLocale)) {
+            throw new Error(`The defaultLocale "${defaultLocale}" must be one of the availableLocales [${availableLocales
+                .map(l => `"${l}"`)
+                .join(', ')}]`);
+        }
+        const uiLanguage = lastLanguage && availableLanguages.includes(lastLanguage) ? lastLanguage : defaultLanguage;
+        this.localStorageService.set('uiLanguageCode', uiLanguage);
+        this.i18nService.setLanguage(uiLanguage);
+        this.i18nService.setDefaultLanguage(defaultLanguage);
+        this.i18nService.setAvailableLanguages(availableLanguages || [defaultLanguage]);
+        this.i18nService.setAvailableLocales(availableLocales || [defaultLocale]);
+    }
+    initUiTitle() {
+        const title = getAppConfig().brand || 'Deenruv';
+        this.titleService.setTitle(title);
+    }
+    initAlerts() {
+        const pendingUpdatesId = 'pending-search-index-updates';
+        this.alertsService.configureAlert({
+            id: pendingUpdatesId,
+            requiredPermissions: [Permission.ReadCatalog, Permission.ReadProduct],
+            check: context => context.dataService.product
+                .getPendingSearchIndexUpdates()
+                .mapSingle(({ pendingSearchIndexUpdates }) => pendingSearchIndexUpdates),
+            recheck: () => interval(1000 * 30),
+            isAlert: data => 0 < data,
+            action: (data, context) => {
+                context.dataService.product.runPendingSearchIndexUpdates().subscribe(() => {
+                    context.notificationService.info(_('catalog.running-search-index-updates'), {
+                        count: data,
+                    });
+                });
+            },
+            label: data => ({
+                text: _('catalog.run-pending-search-index-updates'),
+                translationVars: { count: data },
+            }),
+        });
+        this.alertsService.refresh(pendingUpdatesId);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CoreModule, deps: [{ token: i1.I18nService }, { token: i2.LocalStorageService }, { token: i3.Title }, { token: i4.AlertsService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: CoreModule, declarations: [AppShellComponent,
+            UserMenuComponent,
+            BaseNavComponent,
+            MainNavComponent,
+            SettingsNavComponent,
+            BreadcrumbComponent,
+            OverlayHostComponent,
+            NotificationComponent,
+            UiLanguageSwitcherDialogComponent,
+            ChannelSwitcherComponent,
+            ThemeSwitcherComponent,
+            AlertsComponent], imports: [BrowserModule,
+            DataModule,
+            SharedModule,
+            BrowserAnimationsModule, i5.TranslateModule], exports: [SharedModule, OverlayHostComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CoreModule, providers: [registerDefaultFormInputs(), Title], imports: [BrowserModule,
+            DataModule,
+            SharedModule,
+            BrowserAnimationsModule,
+            TranslateModule.forRoot({
+                loader: {
+                    provide: TranslateLoader,
+                    useFactory: HttpLoaderFactory,
+                    deps: [HttpClient, PlatformLocation],
+                },
+                compiler: { provide: TranslateCompiler, useClass: InjectableTranslateMessageFormatCompiler },
+            }), SharedModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        BrowserModule,
+                        DataModule,
+                        SharedModule,
+                        BrowserAnimationsModule,
+                        TranslateModule.forRoot({
+                            loader: {
+                                provide: TranslateLoader,
+                                useFactory: HttpLoaderFactory,
+                                deps: [HttpClient, PlatformLocation],
+                            },
+                            compiler: { provide: TranslateCompiler, useClass: InjectableTranslateMessageFormatCompiler },
+                        }),
+                    ],
+                    providers: [registerDefaultFormInputs(), Title],
+                    exports: [SharedModule, OverlayHostComponent],
+                    declarations: [
+                        AppShellComponent,
+                        UserMenuComponent,
+                        BaseNavComponent,
+                        MainNavComponent,
+                        SettingsNavComponent,
+                        BreadcrumbComponent,
+                        OverlayHostComponent,
+                        NotificationComponent,
+                        UiLanguageSwitcherDialogComponent,
+                        ChannelSwitcherComponent,
+                        ThemeSwitcherComponent,
+                        AlertsComponent,
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i1.I18nService }, { type: i2.LocalStorageService }, { type: i3.Title }, { type: i4.AlertsService }] });
+export function HttpLoaderFactory(http, location) {
+    // Dynamically get the baseHref, which is configured in the angular.json file
+    const baseHref = location.getBaseHrefFromDOM();
+    return new CustomHttpTranslationLoader(http, baseHref + 'i18n-messages/');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.module.js","sourceRoot":"","sources":["../../../src/lib/core/src/core.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlatformLocation } from '@angular/common';\nimport { HttpClient } from '@angular/common/http';\nimport { NgModule } from '@angular/core';\nimport { BrowserModule, Title } from '@angular/platform-browser';\nimport { BrowserAnimationsModule } from '@angular/platform-browser/animations';\nimport { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';\nimport { TranslateCompiler, TranslateLoader, TranslateModule } from '@ngx-translate/core';\nimport { interval } from 'rxjs';\n\nimport { getAppConfig } from './app.config';\nimport { getDefaultUiLanguage, getDefaultUiLocale } from './common/utilities/get-default-ui-language';\nimport { AlertsComponent } from './components/alerts/alerts.component';\nimport { AppShellComponent } from './components/app-shell/app-shell.component';\nimport { BaseNavComponent } from './components/base-nav/base-nav.component';\nimport { BreadcrumbComponent } from './components/breadcrumb/breadcrumb.component';\nimport { ChannelSwitcherComponent } from './components/channel-switcher/channel-switcher.component';\nimport { MainNavComponent } from './components/main-nav/main-nav.component';\nimport { NotificationComponent } from './components/notification/notification.component';\nimport { OverlayHostComponent } from './components/overlay-host/overlay-host.component';\nimport { SettingsNavComponent } from './components/settings-nav/settings-nav.component';\nimport { ThemeSwitcherComponent } from './components/theme-switcher/theme-switcher.component';\nimport { UiLanguageSwitcherDialogComponent } from './components/ui-language-switcher-dialog/ui-language-switcher-dialog.component';\nimport { UserMenuComponent } from './components/user-menu/user-menu.component';\nimport { DataModule } from './data/data.module';\nimport { AlertsService } from './providers/alerts/alerts.service';\nimport { CustomHttpTranslationLoader } from './providers/i18n/custom-http-loader';\nimport { InjectableTranslateMessageFormatCompiler } from './providers/i18n/custom-message-format-compiler';\nimport { I18nService } from './providers/i18n/i18n.service';\nimport { LocalStorageService } from './providers/local-storage/local-storage.service';\nimport { Permission } from './public_api';\nimport { registerDefaultFormInputs } from './shared/dynamic-form-inputs/default-form-inputs';\nimport { SharedModule } from './shared/shared.module';\n\n@NgModule({\n    imports: [\n        BrowserModule,\n        DataModule,\n        SharedModule,\n        BrowserAnimationsModule,\n        TranslateModule.forRoot({\n            loader: {\n                provide: TranslateLoader,\n                useFactory: HttpLoaderFactory,\n                deps: [HttpClient, PlatformLocation],\n            },\n\n            compiler: { provide: TranslateCompiler, useClass: InjectableTranslateMessageFormatCompiler },\n        }),\n    ],\n    providers: [registerDefaultFormInputs(), Title],\n    exports: [SharedModule, OverlayHostComponent],\n    declarations: [\n        AppShellComponent,\n        UserMenuComponent,\n        BaseNavComponent,\n        MainNavComponent,\n        SettingsNavComponent,\n        BreadcrumbComponent,\n        OverlayHostComponent,\n        NotificationComponent,\n        UiLanguageSwitcherDialogComponent,\n        ChannelSwitcherComponent,\n        ThemeSwitcherComponent,\n        AlertsComponent,\n    ],\n})\nexport class CoreModule {\n    constructor(\n        private i18nService: I18nService,\n        private localStorageService: LocalStorageService,\n        private titleService: Title,\n        private alertsService: AlertsService,\n    ) {\n        this.initUiLanguagesAndLocales();\n        this.initUiTitle();\n        this.initAlerts();\n    }\n\n    private initUiLanguagesAndLocales() {\n        const defaultLanguage = getDefaultUiLanguage();\n        const defaultLocale = getDefaultUiLocale();\n\n        const lastLanguage = this.localStorageService.get('uiLanguageCode');\n        const availableLanguages = getAppConfig().availableLanguages;\n        const availableLocales = getAppConfig().availableLocales ?? [defaultLocale];\n\n        if (!!defaultLanguage && !availableLanguages.includes(defaultLanguage)) {\n            throw new Error(\n                `The defaultLanguage \"${defaultLanguage}\" must be one of the availableLanguages [${availableLanguages\n                    .map(l => `\"${l}\"`)\n                    .join(', ')}]`,\n            );\n        }\n\n        if (!!defaultLocale && !availableLocales.includes(defaultLocale)) {\n            throw new Error(\n                `The defaultLocale \"${defaultLocale}\" must be one of the availableLocales [${availableLocales\n                    .map(l => `\"${l}\"`)\n                    .join(', ')}]`,\n            );\n        }\n\n        const uiLanguage =\n            lastLanguage && availableLanguages.includes(lastLanguage) ? lastLanguage : defaultLanguage;\n\n        this.localStorageService.set('uiLanguageCode', uiLanguage);\n\n        this.i18nService.setLanguage(uiLanguage);\n        this.i18nService.setDefaultLanguage(defaultLanguage);\n        this.i18nService.setAvailableLanguages(availableLanguages || [defaultLanguage]);\n        this.i18nService.setAvailableLocales(availableLocales || [defaultLocale]);\n    }\n\n    private initUiTitle() {\n        const title = getAppConfig().brand || 'Deenruv';\n\n        this.titleService.setTitle(title);\n    }\n\n    private initAlerts() {\n        const pendingUpdatesId = 'pending-search-index-updates';\n        this.alertsService.configureAlert({\n            id: pendingUpdatesId,\n            requiredPermissions: [Permission.ReadCatalog, Permission.ReadProduct],\n            check: context =>\n                context.dataService.product\n                    .getPendingSearchIndexUpdates()\n                    .mapSingle(({ pendingSearchIndexUpdates }) => pendingSearchIndexUpdates),\n            recheck: () => interval(1000 * 30),\n            isAlert: data => 0 < data,\n            action: (data, context) => {\n                context.dataService.product.runPendingSearchIndexUpdates().subscribe(() => {\n                    context.notificationService.info(_('catalog.running-search-index-updates'), {\n                        count: data,\n                    });\n                });\n            },\n            label: data => ({\n                text: _('catalog.run-pending-search-index-updates'),\n                translationVars: { count: data },\n            }),\n        });\n        this.alertsService.refresh(pendingUpdatesId);\n    }\n}\n\nexport function HttpLoaderFactory(http: HttpClient, location: PlatformLocation) {\n    // Dynamically get the baseHref, which is configured in the angular.json file\n    const baseHref = location.getBaseHrefFromDOM();\n    return new CustomHttpTranslationLoader(http, baseHref + 'i18n-messages/');\n}\n"]}

package/esm2022/core/data/check-jobs-link.mjs

@@ -0,0 +1,32 @@
+import { ApolloLink } from '@apollo/client/core';
+import { JobQueueService } from '../providers/job-queue/job-queue.service';
+/**
+ * This link checks each operation and if it is a mutation, it tells the JobQueueService
+ * to poll for active jobs. This is because certain mutations trigger background jobs
+ * which should be made known in the UI.
+ */
+export class CheckJobsLink extends ApolloLink {
+    get jobQueueService() {
+        if (!this._jobQueueService) {
+            this._jobQueueService = this.injector.get(JobQueueService);
+        }
+        return this._jobQueueService;
+    }
+    /**
+     * We inject the Injector rather than the JobQueueService directly in order
+     * to avoid a circular dependency error.
+     */
+    constructor(injector) {
+        super((operation, forward) => {
+            if (this.isMutation(operation)) {
+                this.jobQueueService.checkForJobs();
+            }
+            return forward ? forward(operation) : null;
+        });
+        this.injector = injector;
+    }
+    isMutation(operation) {
+        return !!operation.query.definitions.find(d => d.kind === 'OperationDefinition' && d.operation === 'mutation');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/data/client-state/client-defaults.mjs

@@ -0,0 +1,33 @@
+import { getDefaultUiLanguage, getDefaultUiLocale } from '../../common/utilities/get-default-ui-language';
+export function getClientDefaults(localStorageService) {
+    const currentLanguage = localStorageService.get('uiLanguageCode') || getDefaultUiLanguage();
+    const currentLocale = localStorageService.get('uiLocale') || getDefaultUiLocale();
+    const currentContentLanguage = localStorageService.get('contentLanguageCode') || getDefaultUiLanguage();
+    const activeTheme = localStorageService.get('activeTheme') || 'default';
+    return {
+        networkStatus: {
+            inFlightRequests: 0,
+            __typename: 'NetworkStatus',
+        },
+        userStatus: {
+            administratorId: null,
+            username: '',
+            isLoggedIn: false,
+            loginTime: '',
+            activeChannelId: null,
+            permissions: [],
+            channels: [],
+            __typename: 'UserStatus',
+        },
+        uiState: {
+            language: currentLanguage,
+            locale: currentLocale || '',
+            contentLanguage: currentContentLanguage,
+            theme: activeTheme,
+            displayUiExtensionPoints: false,
+            mainNavExpanded: false,
+            __typename: 'UiState',
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/data/client-state/client-resolvers.mjs

@@ -0,0 +1,136 @@
+import { GET_NEWTORK_STATUS, GET_UI_STATE, GET_USER_STATUS } from '../definitions/client-definitions';
+export const clientResolvers = {
+    Mutation: {
+        requestStarted: (_, args, { cache }) => updateRequestsInFlight(cache, 1),
+        requestCompleted: (_, args, { cache }) => updateRequestsInFlight(cache, -1),
+        setAsLoggedIn: (_, args, { cache }) => {
+            const { input: { username, loginTime, channels, activeChannelId, administratorId }, } = args;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const permissions = channels.find(c => c.id === activeChannelId).permissions;
+            const data = {
+                userStatus: {
+                    __typename: 'UserStatus',
+                    administratorId,
+                    username,
+                    loginTime,
+                    isLoggedIn: true,
+                    permissions,
+                    channels,
+                    activeChannelId,
+                },
+            };
+            cache.writeQuery({ query: GET_USER_STATUS, data });
+            return data.userStatus;
+        },
+        setAsLoggedOut: (_, args, { cache }) => {
+            const data = {
+                userStatus: {
+                    __typename: 'UserStatus',
+                    administratorId: null,
+                    username: '',
+                    loginTime: '',
+                    isLoggedIn: false,
+                    permissions: [],
+                    channels: [],
+                    activeChannelId: null,
+                },
+            };
+            cache.writeQuery({ query: GET_USER_STATUS, data });
+            return data.userStatus;
+        },
+        setUiLanguage: (_, args, { cache }) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const previous = cache.readQuery({ query: GET_UI_STATE });
+            const data = updateUiState(previous, 'language', args.languageCode);
+            cache.writeQuery({ query: GET_UI_STATE, data });
+            return args.languageCode;
+        },
+        setUiLocale: (_, args, { cache }) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const previous = cache.readQuery({ query: GET_UI_STATE });
+            const data = updateUiState(previous, 'locale', args.locale);
+            cache.writeQuery({ query: GET_UI_STATE, data });
+            return args.locale ?? undefined;
+        },
+        setContentLanguage: (_, args, { cache }) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const previous = cache.readQuery({ query: GET_UI_STATE });
+            const data = updateUiState(previous, 'contentLanguage', args.languageCode);
+            cache.writeQuery({ query: GET_UI_STATE, data });
+            return args.languageCode;
+        },
+        setUiTheme: (_, args, { cache }) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const previous = cache.readQuery({ query: GET_UI_STATE });
+            const data = updateUiState(previous, 'theme', args.theme);
+            cache.writeQuery({ query: GET_UI_STATE, data });
+            return args.theme;
+        },
+        setDisplayUiExtensionPoints: (_, args, { cache }) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const previous = cache.readQuery({ query: GET_UI_STATE });
+            const data = updateUiState(previous, 'displayUiExtensionPoints', args.display);
+            cache.writeQuery({ query: GET_UI_STATE, data });
+            return args.display;
+        },
+        setMainNavExpanded: (_, args, { cache }) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const previous = cache.readQuery({ query: GET_UI_STATE });
+            const data = updateUiState(previous, 'mainNavExpanded', args.expanded);
+            cache.writeQuery({ query: GET_UI_STATE, data });
+            return args.expanded;
+        },
+        setActiveChannel: (_, args, { cache }) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const previous = cache.readQuery({ query: GET_USER_STATUS });
+            const activeChannel = previous.userStatus.channels.find(c => c.id === args.channelId);
+            if (!activeChannel) {
+                throw new Error('setActiveChannel: Could not find Channel with ID ' + args.channelId);
+            }
+            const permissions = activeChannel.permissions;
+            const data = {
+                userStatus: {
+                    ...previous.userStatus,
+                    permissions,
+                    activeChannelId: activeChannel.id,
+                },
+            };
+            cache.writeQuery({ query: GET_USER_STATUS, data });
+            return data.userStatus;
+        },
+        updateUserChannels: (_, args, { cache }) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const previous = cache.readQuery({ query: GET_USER_STATUS });
+            const data = {
+                userStatus: {
+                    ...previous.userStatus,
+                    channels: Array.isArray(args.channels) ? args.channels : [args.channels],
+                },
+            };
+            cache.writeQuery({ query: GET_USER_STATUS, data });
+            return data.userStatus;
+        },
+    },
+};
+function updateUiState(previous, key, value) {
+    return {
+        uiState: {
+            ...previous.uiState,
+            [key]: value,
+            __typename: 'UiState',
+        },
+    };
+}
+function updateRequestsInFlight(cache, increment) {
+    const previous = cache.readQuery({ query: GET_NEWTORK_STATUS });
+    const inFlightRequests = previous ? previous.networkStatus.inFlightRequests + increment : increment;
+    const data = {
+        networkStatus: {
+            __typename: 'NetworkStatus',
+            inFlightRequests,
+        },
+    };
+    cache.writeQuery({ query: GET_NEWTORK_STATUS, data });
+    return inFlightRequests;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client-resolvers.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/client-state/client-resolvers.ts"],"names":[],"mappings":"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","sourcesContent":["import { InMemoryCache } from '@apollo/client/core';\n\nimport * as Codegen from '../../common/generated-types';\nimport { GetUserStatusQuery, LanguageCode, UserStatus } from '../../common/generated-types';\nimport { GET_NEWTORK_STATUS, GET_UI_STATE, GET_USER_STATUS } from '../definitions/client-definitions';\n\nexport type ResolverContext = {\n    cache: InMemoryCache;\n    optimisticResponse: any;\n    getCacheKey: (storeObj: any) => string;\n};\n\nexport type ResolverDefinition = {\n    Mutation: {\n        [name: string]: (rootValue: any, args: any, context: ResolverContext, info?: any) => any;\n    };\n};\n\nexport const clientResolvers: ResolverDefinition = {\n    Mutation: {\n        requestStarted: (_, args, { cache }): number => updateRequestsInFlight(cache, 1),\n        requestCompleted: (_, args, { cache }): number => updateRequestsInFlight(cache, -1),\n        setAsLoggedIn: (_, args: Codegen.SetAsLoggedInMutationVariables, { cache }): UserStatus => {\n            const {\n                input: { username, loginTime, channels, activeChannelId, administratorId },\n            } = args;\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const permissions = channels.find(c => c.id === activeChannelId)!.permissions;\n            const data: { userStatus: UserStatus } = {\n                userStatus: {\n                    __typename: 'UserStatus',\n                    administratorId,\n                    username,\n                    loginTime,\n                    isLoggedIn: true,\n                    permissions,\n                    channels,\n                    activeChannelId,\n                },\n            };\n            cache.writeQuery({ query: GET_USER_STATUS, data });\n            return data.userStatus;\n        },\n        setAsLoggedOut: (_, args, { cache }): UserStatus => {\n            const data: GetUserStatusQuery = {\n                userStatus: {\n                    __typename: 'UserStatus',\n                    administratorId: null,\n                    username: '',\n                    loginTime: '',\n                    isLoggedIn: false,\n                    permissions: [],\n                    channels: [],\n                    activeChannelId: null,\n                },\n            };\n            cache.writeQuery({ query: GET_USER_STATUS, data });\n            return data.userStatus;\n        },\n        setUiLanguage: (_, args: Codegen.SetUiLanguageMutationVariables, { cache }): LanguageCode => {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const previous = cache.readQuery<Codegen.GetUiStateQuery>({ query: GET_UI_STATE })!;\n            const data = updateUiState(previous, 'language', args.languageCode);\n            cache.writeQuery({ query: GET_UI_STATE, data });\n            return args.languageCode;\n        },\n        setUiLocale: (_, args: Codegen.SetUiLocaleMutationVariables, { cache }): string | undefined => {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const previous = cache.readQuery<Codegen.GetUiStateQuery>({ query: GET_UI_STATE })!;\n            const data = updateUiState(previous, 'locale', args.locale);\n            cache.writeQuery({ query: GET_UI_STATE, data });\n            return args.locale ?? undefined;\n        },\n        setContentLanguage: (\n            _,\n            args: Codegen.SetContentLanguageMutationVariables,\n            { cache },\n        ): LanguageCode => {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const previous = cache.readQuery<Codegen.GetUiStateQuery>({ query: GET_UI_STATE })!;\n            const data = updateUiState(previous, 'contentLanguage', args.languageCode);\n            cache.writeQuery({ query: GET_UI_STATE, data });\n            return args.languageCode;\n        },\n        setUiTheme: (_, args: Codegen.SetUiThemeMutationVariables, { cache }): string => {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const previous = cache.readQuery<Codegen.GetUiStateQuery>({ query: GET_UI_STATE })!;\n            const data = updateUiState(previous, 'theme', args.theme);\n            cache.writeQuery({ query: GET_UI_STATE, data });\n            return args.theme;\n        },\n        setDisplayUiExtensionPoints: (\n            _,\n            args: Codegen.SetDisplayUiExtensionPointsMutationVariables,\n            { cache },\n        ): boolean => {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const previous = cache.readQuery<Codegen.GetUiStateQuery>({ query: GET_UI_STATE })!;\n            const data = updateUiState(previous, 'displayUiExtensionPoints', args.display);\n            cache.writeQuery({ query: GET_UI_STATE, data });\n            return args.display;\n        },\n        setMainNavExpanded: (_, args: Codegen.SetMainNavExpandedMutationVariables, { cache }): boolean => {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const previous = cache.readQuery<Codegen.GetUiStateQuery>({ query: GET_UI_STATE })!;\n            const data = updateUiState(previous, 'mainNavExpanded', args.expanded);\n            cache.writeQuery({ query: GET_UI_STATE, data });\n            return args.expanded;\n        },\n        setActiveChannel: (_, args: Codegen.SetActiveChannelMutationVariables, { cache }): UserStatus => {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const previous = cache.readQuery<GetUserStatusQuery>({ query: GET_USER_STATUS })!;\n            const activeChannel = previous.userStatus.channels.find(c => c.id === args.channelId);\n            if (!activeChannel) {\n                throw new Error('setActiveChannel: Could not find Channel with ID ' + args.channelId);\n            }\n            const permissions = activeChannel.permissions;\n            const data: { userStatus: UserStatus } = {\n                userStatus: {\n                    ...previous.userStatus,\n                    permissions,\n                    activeChannelId: activeChannel.id,\n                },\n            };\n            cache.writeQuery({ query: GET_USER_STATUS, data });\n            return data.userStatus;\n        },\n        updateUserChannels: (_, args: Codegen.UpdateUserChannelsMutationVariables, { cache }): UserStatus => {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const previous = cache.readQuery<GetUserStatusQuery>({ query: GET_USER_STATUS })!;\n            const data = {\n                userStatus: {\n                    ...previous.userStatus,\n                    channels: Array.isArray(args.channels) ? args.channels : [args.channels],\n                },\n            };\n            cache.writeQuery({ query: GET_USER_STATUS, data });\n            return data.userStatus;\n        },\n    },\n};\n\nfunction updateUiState<K extends keyof Codegen.GetUiStateQuery['uiState']>(\n    previous: Codegen.GetUiStateQuery,\n    key: K,\n    value: Codegen.GetUiStateQuery['uiState'][K],\n): Codegen.GetUiStateQuery {\n    return {\n        uiState: {\n            ...previous.uiState,\n            [key]: value,\n            __typename: 'UiState',\n        },\n    };\n}\n\nfunction updateRequestsInFlight(cache: InMemoryCache, increment: 1 | -1): number {\n    const previous = cache.readQuery<Codegen.GetNetworkStatusQuery>({ query: GET_NEWTORK_STATUS });\n    const inFlightRequests = previous ? previous.networkStatus.inFlightRequests + increment : increment;\n    const data: Codegen.GetNetworkStatusQuery = {\n        networkStatus: {\n            __typename: 'NetworkStatus',\n            inFlightRequests,\n        },\n    };\n    cache.writeQuery({ query: GET_NEWTORK_STATUS, data });\n    return inFlightRequests;\n}\n"]}

package/esm2022/core/data/data.module.mjs

@@ -0,0 +1,135 @@
+import { HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
+import { APP_INITIALIZER, Injector, NgModule } from '@angular/core';
+import { InMemoryCache } from '@apollo/client/core';
+import { setContext } from '@apollo/client/link/context';
+import { ApolloLink } from '@apollo/client/link/core';
+import { ApolloModule, APOLLO_OPTIONS } from 'apollo-angular';
+import createUploadLink from 'apollo-upload-client/createUploadLink.mjs';
+import { getAppConfig } from '../app.config';
+import { introspectionResult } from '../common/introspection-result-wrapper';
+import { LocalStorageService } from '../providers/local-storage/local-storage.service';
+import { CheckJobsLink } from './check-jobs-link';
+import { getClientDefaults } from './client-state/client-defaults';
+import { clientResolvers } from './client-state/client-resolvers';
+import { GET_CLIENT_STATE } from './definitions/client-definitions';
+import { OmitTypenameLink } from './omit-typename-link';
+import { BaseDataService } from './providers/base-data.service';
+import { DataService } from './providers/data.service';
+import { FetchAdapter } from './providers/fetch-adapter';
+import { DefaultInterceptor } from './providers/interceptor';
+import { initializeServerConfigService, ServerConfigService } from './server-config';
+import { getServerLocation } from './utils/get-server-location';
+import * as i0 from "@angular/core";
+export function createApollo(localStorageService, fetchAdapter, injector) {
+    const { adminApiPath, tokenMethod, channelTokenKey } = getAppConfig();
+    const serverLocation = getServerLocation();
+    const apolloCache = new InMemoryCache({
+        possibleTypes: introspectionResult.possibleTypes,
+        typePolicies: {
+            GlobalSettings: {
+                fields: {
+                    serverConfig: {
+                        merge: (existing, incoming) => ({ ...existing, ...incoming }),
+                    },
+                },
+            },
+            Facet: {
+                fields: {
+                    values: {
+                        merge: (existing, incoming) => incoming,
+                    },
+                },
+            },
+        },
+    });
+    apolloCache.writeQuery({
+        query: GET_CLIENT_STATE,
+        data: getClientDefaults(localStorageService),
+    });
+    if (!false) {
+        // TODO: enable only for dev mode
+        // make the Apollo Cache inspectable in the console for debug purposes
+        window['apolloCache'] = apolloCache;
+    }
+    return {
+        link: ApolloLink.from([
+            new OmitTypenameLink(),
+            new CheckJobsLink(injector),
+            setContext(() => {
+                const headers = {};
+                const channelToken = localStorageService.get('activeChannelToken');
+                if (channelToken) {
+                    headers[channelTokenKey ?? 'deenruv-token'] = channelToken;
+                }
+                if (tokenMethod === 'bearer') {
+                    const authToken = localStorageService.get('authToken');
+                    if (authToken) {
+                        headers.authorization = `Bearer ${authToken}`;
+                    }
+                }
+                headers['Apollo-Require-Preflight'] = 'true';
+                return { headers };
+            }),
+            createUploadLink({
+                uri: `${serverLocation}/${adminApiPath}`,
+                fetch: fetchAdapter.fetch,
+            }),
+        ]),
+        cache: apolloCache,
+        resolvers: clientResolvers,
+    };
+}
+// List of all EU countries
+/**
+ * The DataModule is responsible for all API calls *and* serves as the source of truth for global app
+ * state via the apollo-link-state package.
+ */
+export class DataModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: DataModule, imports: [HttpClientModule, ApolloModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataModule, providers: [
+            BaseDataService,
+            DataService,
+            FetchAdapter,
+            ServerConfigService,
+            {
+                provide: APOLLO_OPTIONS,
+                useFactory: createApollo,
+                deps: [LocalStorageService, FetchAdapter, Injector],
+            },
+            { provide: HTTP_INTERCEPTORS, useClass: DefaultInterceptor, multi: true },
+            {
+                provide: APP_INITIALIZER,
+                multi: true,
+                useFactory: initializeServerConfigService,
+                deps: [ServerConfigService],
+            },
+        ], imports: [HttpClientModule, ApolloModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DataModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [HttpClientModule, ApolloModule],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        BaseDataService,
+                        DataService,
+                        FetchAdapter,
+                        ServerConfigService,
+                        {
+                            provide: APOLLO_OPTIONS,
+                            useFactory: createApollo,
+                            deps: [LocalStorageService, FetchAdapter, Injector],
+                        },
+                        { provide: HTTP_INTERCEPTORS, useClass: DefaultInterceptor, multi: true },
+                        {
+                            provide: APP_INITIALIZER,
+                            multi: true,
+                            useFactory: initializeServerConfigService,
+                            deps: [ServerConfigService],
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data.module.js","sourceRoot":"","sources":["../../../../src/lib/core/src/data/data.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';\nimport { APP_INITIALIZER, Injector, NgModule } from '@angular/core';\nimport { ApolloClientOptions, InMemoryCache } from '@apollo/client/core';\nimport { setContext } from '@apollo/client/link/context';\nimport { ApolloLink } from '@apollo/client/link/core';\nimport { ApolloModule, APOLLO_OPTIONS } from 'apollo-angular';\nimport createUploadLink from 'apollo-upload-client/createUploadLink.mjs';\n\nimport { getAppConfig } from '../app.config';\nimport { introspectionResult } from '../common/introspection-result-wrapper';\nimport { LocalStorageService } from '../providers/local-storage/local-storage.service';\n\nimport { CheckJobsLink } from './check-jobs-link';\nimport { getClientDefaults } from './client-state/client-defaults';\nimport { clientResolvers } from './client-state/client-resolvers';\nimport { GET_CLIENT_STATE } from './definitions/client-definitions';\nimport { OmitTypenameLink } from './omit-typename-link';\nimport { BaseDataService } from './providers/base-data.service';\nimport { DataService } from './providers/data.service';\nimport { FetchAdapter } from './providers/fetch-adapter';\nimport { DefaultInterceptor } from './providers/interceptor';\nimport { initializeServerConfigService, ServerConfigService } from './server-config';\nimport { getServerLocation } from './utils/get-server-location';\n\nexport function createApollo(\n    localStorageService: LocalStorageService,\n    fetchAdapter: FetchAdapter,\n    injector: Injector,\n): ApolloClientOptions<any> {\n    const { adminApiPath, tokenMethod, channelTokenKey } = getAppConfig();\n    const serverLocation = getServerLocation();\n    const apolloCache = new InMemoryCache({\n        possibleTypes: introspectionResult.possibleTypes,\n        typePolicies: {\n            GlobalSettings: {\n                fields: {\n                    serverConfig: {\n                        merge: (existing, incoming) => ({ ...existing, ...incoming }),\n                    },\n                },\n            },\n            Facet: {\n                fields: {\n                    values: {\n                        merge: (existing, incoming) => incoming,\n                    },\n                },\n            },\n        },\n    });\n    apolloCache.writeQuery({\n        query: GET_CLIENT_STATE,\n        data: getClientDefaults(localStorageService),\n    });\n\n    if (!false) {\n        // TODO: enable only for dev mode\n        // make the Apollo Cache inspectable in the console for debug purposes\n        (window as any)['apolloCache'] = apolloCache;\n    }\n    return {\n        link: ApolloLink.from([\n            new OmitTypenameLink(),\n            new CheckJobsLink(injector),\n            setContext(() => {\n                const headers: Record<string, string> = {};\n                const channelToken = localStorageService.get('activeChannelToken');\n                if (channelToken) {\n                    headers[channelTokenKey ?? 'deenruv-token'] = channelToken;\n                }\n                if (tokenMethod === 'bearer') {\n                    const authToken = localStorageService.get('authToken');\n                    if (authToken) {\n                        headers.authorization = `Bearer ${authToken}`;\n                    }\n                }\n                headers['Apollo-Require-Preflight'] = 'true';\n                return { headers };\n            }),\n            createUploadLink({\n                uri: `${serverLocation}/${adminApiPath}`,\n                fetch: fetchAdapter.fetch,\n            }),\n        ]),\n        cache: apolloCache,\n        resolvers: clientResolvers,\n    };\n}\n\n// List of all EU countries\n\n/**\n * The DataModule is responsible for all API calls *and* serves as the source of truth for global app\n * state via the apollo-link-state package.\n */\n@NgModule({\n    imports: [HttpClientModule, ApolloModule],\n    exports: [],\n    declarations: [],\n    providers: [\n        BaseDataService,\n        DataService,\n        FetchAdapter,\n        ServerConfigService,\n        {\n            provide: APOLLO_OPTIONS,\n            useFactory: createApollo,\n            deps: [LocalStorageService, FetchAdapter, Injector],\n        },\n        { provide: HTTP_INTERCEPTORS, useClass: DefaultInterceptor, multi: true },\n        {\n            provide: APP_INITIALIZER,\n            multi: true,\n            useFactory: initializeServerConfigService,\n            deps: [ServerConfigService],\n        },\n    ],\n})\nexport class DataModule {}\n"]}