@vendure/admin-ui 1.4.7 → 2.0.0-next.0

package/esm2020/core/core.module.mjs

@@ -0,0 +1,145 @@
+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 { TranslateCompiler, TranslateLoader, TranslateModule } from '@ngx-translate/core';
+import { MESSAGE_FORMAT_CONFIG } from 'ngx-translate-messageformat-compiler';
+import { getAppConfig } from './app.config';
+import { getDefaultUiLanguage } from './common/utilities/get-default-ui-language';
+import { AppShellComponent } from './components/app-shell/app-shell.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 { 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 { registerDefaultFormInputs } from './shared/dynamic-form-inputs/register-dynamic-input-components';
+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 "@ngx-translate/core";
+export class CoreModule {
+    constructor(i18nService, localStorageService, titleService) {
+        this.i18nService = i18nService;
+        this.localStorageService = localStorageService;
+        this.titleService = titleService;
+        this.initUiLanguages();
+        this.initUiTitle();
+    }
+    initUiLanguages() {
+        const defaultLanguage = getDefaultUiLanguage();
+        const lastLanguage = this.localStorageService.get('uiLanguageCode');
+        const availableLanguages = getAppConfig().availableLanguages;
+        if (!availableLanguages.includes(defaultLanguage)) {
+            throw new Error(`The defaultLanguage "${defaultLanguage}" must be one of the availableLanguages [${availableLanguages
+                .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]);
+    }
+    initUiTitle() {
+        const title = getAppConfig().brand || 'VendureAdmin';
+        this.titleService.setTitle(title);
+    }
+}
+CoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CoreModule, deps: [{ token: i1.I18nService }, { token: i2.LocalStorageService }, { token: i3.Title }], target: i0.ɵɵFactoryTarget.NgModule });
+CoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CoreModule, declarations: [AppShellComponent,
+        UserMenuComponent,
+        MainNavComponent,
+        BreadcrumbComponent,
+        OverlayHostComponent,
+        NotificationComponent,
+        UiLanguageSwitcherDialogComponent,
+        ChannelSwitcherComponent,
+        ThemeSwitcherComponent], imports: [BrowserModule,
+        DataModule,
+        SharedModule,
+        BrowserAnimationsModule, i4.TranslateModule], exports: [SharedModule, OverlayHostComponent] });
+CoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CoreModule, providers: [
+        { provide: MESSAGE_FORMAT_CONFIG, useFactory: getLocales },
+        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: "13.2.3", 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: [
+                        { provide: MESSAGE_FORMAT_CONFIG, useFactory: getLocales },
+                        registerDefaultFormInputs(),
+                        Title,
+                    ],
+                    exports: [SharedModule, OverlayHostComponent],
+                    declarations: [
+                        AppShellComponent,
+                        UserMenuComponent,
+                        MainNavComponent,
+                        BreadcrumbComponent,
+                        OverlayHostComponent,
+                        NotificationComponent,
+                        UiLanguageSwitcherDialogComponent,
+                        ChannelSwitcherComponent,
+                        ThemeSwitcherComponent,
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.I18nService }, { type: i2.LocalStorageService }, { type: i3.Title }]; } });
+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/');
+}
+/**
+ * Returns the locales defined in the vendure-ui-config.json, ensuring that the
+ * default language is the first item in the array as per the messageformat
+ * documentation:
+ *
+ * > The default locale will be the first entry of the array
+ * https://messageformat.github.io/messageformat/MessageFormat
+ */
+export function getLocales() {
+    const locales = getAppConfig().availableLanguages;
+    const defaultLanguage = getDefaultUiLanguage();
+    const localesWithoutDefault = locales.filter(l => l !== defaultLanguage);
+    return {
+        locales: [defaultLanguage, ...localesWithoutDefault],
+    };
+}
+//# 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';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { NgModule } from '@angular/core';\r\nimport { BrowserModule, Title } from '@angular/platform-browser';\r\nimport { BrowserAnimationsModule } from '@angular/platform-browser/animations';\r\nimport { TranslateCompiler, TranslateLoader, TranslateModule } from '@ngx-translate/core';\r\nimport { MessageFormatConfig, MESSAGE_FORMAT_CONFIG } from 'ngx-translate-messageformat-compiler';\r\n\r\nimport { getAppConfig } from './app.config';\r\nimport { getDefaultUiLanguage } from './common/utilities/get-default-ui-language';\r\nimport { AppShellComponent } from './components/app-shell/app-shell.component';\r\nimport { BreadcrumbComponent } from './components/breadcrumb/breadcrumb.component';\r\nimport { ChannelSwitcherComponent } from './components/channel-switcher/channel-switcher.component';\r\nimport { MainNavComponent } from './components/main-nav/main-nav.component';\r\nimport { NotificationComponent } from './components/notification/notification.component';\r\nimport { OverlayHostComponent } from './components/overlay-host/overlay-host.component';\r\nimport { ThemeSwitcherComponent } from './components/theme-switcher/theme-switcher.component';\r\nimport { UiLanguageSwitcherDialogComponent } from './components/ui-language-switcher-dialog/ui-language-switcher-dialog.component';\r\nimport { UserMenuComponent } from './components/user-menu/user-menu.component';\r\nimport { DataModule } from './data/data.module';\r\nimport { CustomHttpTranslationLoader } from './providers/i18n/custom-http-loader';\r\nimport { InjectableTranslateMessageFormatCompiler } from './providers/i18n/custom-message-format-compiler';\r\nimport { I18nService } from './providers/i18n/i18n.service';\r\nimport { LocalStorageService } from './providers/local-storage/local-storage.service';\r\nimport { registerDefaultFormInputs } from './shared/dynamic-form-inputs/register-dynamic-input-components';\r\nimport { SharedModule } from './shared/shared.module';\r\n\r\n@NgModule({\r\n    imports: [\r\n        BrowserModule,\r\n        DataModule,\r\n        SharedModule,\r\n        BrowserAnimationsModule,\r\n        TranslateModule.forRoot({\r\n            loader: {\r\n                provide: TranslateLoader,\r\n                useFactory: HttpLoaderFactory,\r\n                deps: [HttpClient, PlatformLocation],\r\n            },\r\n            compiler: { provide: TranslateCompiler, useClass: InjectableTranslateMessageFormatCompiler },\r\n        }),\r\n    ],\r\n    providers: [\r\n        { provide: MESSAGE_FORMAT_CONFIG, useFactory: getLocales },\r\n        registerDefaultFormInputs(),\r\n        Title,\r\n    ],\r\n    exports: [SharedModule, OverlayHostComponent],\r\n    declarations: [\r\n        AppShellComponent,\r\n        UserMenuComponent,\r\n        MainNavComponent,\r\n        BreadcrumbComponent,\r\n        OverlayHostComponent,\r\n        NotificationComponent,\r\n        UiLanguageSwitcherDialogComponent,\r\n        ChannelSwitcherComponent,\r\n        ThemeSwitcherComponent,\r\n    ],\r\n})\r\nexport class CoreModule {\r\n    constructor(\r\n        private i18nService: I18nService,\r\n        private localStorageService: LocalStorageService,\r\n        private titleService: Title,\r\n    ) {\r\n        this.initUiLanguages();\r\n        this.initUiTitle();\r\n    }\r\n\r\n    private initUiLanguages() {\r\n        const defaultLanguage = getDefaultUiLanguage();\r\n        const lastLanguage = this.localStorageService.get('uiLanguageCode');\r\n        const availableLanguages = getAppConfig().availableLanguages;\r\n\r\n        if (!availableLanguages.includes(defaultLanguage)) {\r\n            throw new Error(\r\n                `The defaultLanguage \"${defaultLanguage}\" must be one of the availableLanguages [${availableLanguages\r\n                    .map(l => `\"${l}\"`)\r\n                    .join(', ')}]`,\r\n            );\r\n        }\r\n        const uiLanguage =\r\n            lastLanguage && availableLanguages.includes(lastLanguage) ? lastLanguage : defaultLanguage;\r\n        this.localStorageService.set('uiLanguageCode', uiLanguage);\r\n        this.i18nService.setLanguage(uiLanguage);\r\n        this.i18nService.setDefaultLanguage(defaultLanguage);\r\n        this.i18nService.setAvailableLanguages(availableLanguages || [defaultLanguage]);\r\n    }\r\n\r\n    private initUiTitle() {\r\n        const title = getAppConfig().brand || 'VendureAdmin';\r\n\r\n        this.titleService.setTitle(title);\r\n    }\r\n}\r\n\r\nexport function HttpLoaderFactory(http: HttpClient, location: PlatformLocation) {\r\n    // Dynamically get the baseHref, which is configured in the angular.json file\r\n    const baseHref = location.getBaseHrefFromDOM();\r\n    return new CustomHttpTranslationLoader(http, baseHref + 'i18n-messages/');\r\n}\r\n\r\n/**\r\n * Returns the locales defined in the vendure-ui-config.json, ensuring that the\r\n * default language is the first item in the array as per the messageformat\r\n * documentation:\r\n *\r\n * > The default locale will be the first entry of the array\r\n * https://messageformat.github.io/messageformat/MessageFormat\r\n */\r\nexport function getLocales(): MessageFormatConfig {\r\n    const locales = getAppConfig().availableLanguages;\r\n    const defaultLanguage = getDefaultUiLanguage();\r\n    const localesWithoutDefault = locales.filter(l => l !== defaultLanguage);\r\n    return {\r\n        locales: [defaultLanguage, ...localesWithoutDefault],\r\n    };\r\n}\r\n"]}

package/{esm2015/core/data/client-state/client-defaults.js → esm2020/core/data/client-state/client-defaults.mjs}

@@ -28,4 +28,4 @@ export function getClientDefaults(localStorageService) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/esm2020/core/data/data.module.mjs

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