@vendure/admin-ui 1.5.0 → 2.0.0-next.2

package/esm2020/core/data/providers/shipping-method-data.service.mjs

@@ -0,0 +1,66 @@
+import { pick } from '@vendure/common/lib/pick';
+import { CREATE_SHIPPING_METHOD, DELETE_SHIPPING_METHOD, GET_SHIPPING_METHOD, GET_SHIPPING_METHOD_LIST, GET_SHIPPING_METHOD_OPERATIONS, TEST_ELIGIBLE_SHIPPING_METHODS, TEST_SHIPPING_METHOD, UPDATE_SHIPPING_METHOD, } from '../definitions/shipping-definitions';
+export class ShippingMethodDataService {
+    constructor(baseDataService) {
+        this.baseDataService = baseDataService;
+    }
+    getShippingMethods(take = 10, skip = 0) {
+        return this.baseDataService.query(GET_SHIPPING_METHOD_LIST, {
+            options: {
+                take,
+                skip,
+            },
+        });
+    }
+    getShippingMethod(id) {
+        return this.baseDataService.query(GET_SHIPPING_METHOD, {
+            id,
+        });
+    }
+    getShippingMethodOperations() {
+        return this.baseDataService.query(GET_SHIPPING_METHOD_OPERATIONS);
+    }
+    createShippingMethod(input) {
+        const variables = {
+            input: pick(input, [
+                'code',
+                'checker',
+                'calculator',
+                'fulfillmentHandler',
+                'customFields',
+                'translations',
+            ]),
+        };
+        return this.baseDataService.mutate(CREATE_SHIPPING_METHOD, variables);
+    }
+    updateShippingMethod(input) {
+        const variables = {
+            input: pick(input, [
+                'id',
+                'code',
+                'checker',
+                'calculator',
+                'fulfillmentHandler',
+                'customFields',
+                'translations',
+            ]),
+        };
+        return this.baseDataService.mutate(UPDATE_SHIPPING_METHOD, variables);
+    }
+    deleteShippingMethod(id) {
+        return this.baseDataService.mutate(DELETE_SHIPPING_METHOD, {
+            id,
+        });
+    }
+    testShippingMethod(input) {
+        return this.baseDataService.query(TEST_SHIPPING_METHOD, {
+            input,
+        });
+    }
+    testEligibleShippingMethods(input) {
+        return this.baseDataService.query(TEST_ELIGIBLE_SHIPPING_METHODS, {
+            input,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/data/query-result.mjs

@@ -0,0 +1,77 @@
+import { NetworkStatus } from '@apollo/client/core';
+import { notNullOrUndefined } from '@vendure/common/lib/shared-utils';
+import { merge, Subject } from 'rxjs';
+import { distinctUntilChanged, filter, finalize, map, skip, take, takeUntil, tap } from 'rxjs/operators';
+import { GET_USER_STATUS } from './definitions/client-definitions';
+/**
+ * @description
+ * This class wraps the Apollo Angular QueryRef object and exposes some getters
+ * for convenience.
+ *
+ * @docsCategory providers
+ * @docsPage DataService
+ */
+export class QueryResult {
+    constructor(queryRef, apollo) {
+        this.queryRef = queryRef;
+        this.apollo = apollo;
+        this.completed$ = new Subject();
+        this.valueChanges = queryRef.valueChanges;
+    }
+    /**
+     * @description
+     * Re-fetch this query whenever the active Channel changes.
+     */
+    refetchOnChannelChange() {
+        const userStatus$ = this.apollo.watchQuery({
+            query: GET_USER_STATUS,
+        }).valueChanges;
+        const activeChannelId$ = userStatus$.pipe(map(data => data.data.userStatus.activeChannelId), filter(notNullOrUndefined), distinctUntilChanged(), skip(1), takeUntil(this.completed$));
+        const loggedOut$ = userStatus$.pipe(map(data => data.data.userStatus.isLoggedIn), distinctUntilChanged(), skip(1), filter(isLoggedIn => !isLoggedIn), takeUntil(this.completed$));
+        this.valueChanges = merge(activeChannelId$, this.queryRef.valueChanges).pipe(tap(val => {
+            if (typeof val === 'string') {
+                new Promise(resolve => setTimeout(resolve, 50)).then(() => this.queryRef.refetch());
+            }
+        }), filter(val => typeof val !== 'string'), takeUntil(loggedOut$), takeUntil(this.completed$));
+        this.queryRef.valueChanges = this.valueChanges;
+        return this;
+    }
+    /**
+     * @description
+     * Returns an Observable which emits a single result and then completes.
+     */
+    get single$() {
+        return this.valueChanges.pipe(filter(result => result.networkStatus === NetworkStatus.ready), take(1), map(result => result.data), finalize(() => {
+            this.completed$.next();
+            this.completed$.complete();
+        }));
+    }
+    /**
+     * @description
+     * Returns an Observable which emits until unsubscribed.
+     */
+    get stream$() {
+        return this.valueChanges.pipe(filter(result => result.networkStatus === NetworkStatus.ready), map(result => result.data), finalize(() => {
+            this.completed$.next();
+            this.completed$.complete();
+        }));
+    }
+    get ref() {
+        return this.queryRef;
+    }
+    /**
+     * @description
+     * Returns a single-result Observable after applying the map function.
+     */
+    mapSingle(mapFn) {
+        return this.single$.pipe(map(mapFn));
+    }
+    /**
+     * @description
+     * Returns a multiple-result Observable after applying the map function.
+     */
+    mapStream(mapFn) {
+        return this.stream$.pipe(map(mapFn));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-result.js","sourceRoot":"","sources":["../../../../src/lib/core/src/data/query-result.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApolloQueryResult, NetworkStatus } from '@apollo/client/core';\r\nimport { notNullOrUndefined } from '@vendure/common/lib/shared-utils';\r\nimport { Apollo, QueryRef } from 'apollo-angular';\r\nimport { merge, Observable, Subject } from 'rxjs';\r\nimport { distinctUntilChanged, filter, finalize, map, skip, take, takeUntil, tap } from 'rxjs/operators';\r\n\r\nimport { GetUserStatusQuery } from '../common/generated-types';\r\n\r\nimport { GET_USER_STATUS } from './definitions/client-definitions';\r\n\r\n/**\r\n * @description\r\n * This class wraps the Apollo Angular QueryRef object and exposes some getters\r\n * for convenience.\r\n *\r\n * @docsCategory providers\r\n * @docsPage DataService\r\n */\r\nexport class QueryResult<T, V = Record<string, any>> {\r\n    constructor(private queryRef: QueryRef<T, V>, private apollo: Apollo) {\r\n        this.valueChanges = queryRef.valueChanges;\r\n    }\r\n\r\n    completed$ = new Subject<void>();\r\n    private valueChanges: Observable<ApolloQueryResult<T>>;\r\n\r\n    /**\r\n     * @description\r\n     * Re-fetch this query whenever the active Channel changes.\r\n     */\r\n    refetchOnChannelChange(): QueryResult<T, V> {\r\n        const userStatus$ = this.apollo.watchQuery<GetUserStatusQuery>({\r\n            query: GET_USER_STATUS,\r\n        }).valueChanges;\r\n        const activeChannelId$ = userStatus$.pipe(\r\n            map(data => data.data.userStatus.activeChannelId),\r\n            filter(notNullOrUndefined),\r\n            distinctUntilChanged(),\r\n            skip(1),\r\n            takeUntil(this.completed$),\r\n        );\r\n        const loggedOut$ = userStatus$.pipe(\r\n            map(data => data.data.userStatus.isLoggedIn),\r\n            distinctUntilChanged(),\r\n            skip(1),\r\n            filter(isLoggedIn => !isLoggedIn),\r\n            takeUntil(this.completed$),\r\n        );\r\n\r\n        this.valueChanges = merge(activeChannelId$, this.queryRef.valueChanges).pipe(\r\n            tap(val => {\r\n                if (typeof val === 'string') {\r\n                    new Promise(resolve => setTimeout(resolve, 50)).then(() => this.queryRef.refetch());\r\n                }\r\n            }),\r\n            filter<any>(val => typeof val !== 'string'),\r\n            takeUntil(loggedOut$),\r\n            takeUntil(this.completed$),\r\n        );\r\n        this.queryRef.valueChanges = this.valueChanges;\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns an Observable which emits a single result and then completes.\r\n     */\r\n    get single$(): Observable<T> {\r\n        return this.valueChanges.pipe(\r\n            filter(result => result.networkStatus === NetworkStatus.ready),\r\n            take(1),\r\n            map(result => result.data),\r\n            finalize(() => {\r\n                this.completed$.next();\r\n                this.completed$.complete();\r\n            }),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns an Observable which emits until unsubscribed.\r\n     */\r\n    get stream$(): Observable<T> {\r\n        return this.valueChanges.pipe(\r\n            filter(result => result.networkStatus === NetworkStatus.ready),\r\n            map(result => result.data),\r\n            finalize(() => {\r\n                this.completed$.next();\r\n                this.completed$.complete();\r\n            }),\r\n        );\r\n    }\r\n\r\n    get ref(): QueryRef<T, V> {\r\n        return this.queryRef;\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns a single-result Observable after applying the map function.\r\n     */\r\n    mapSingle<R>(mapFn: (item: T) => R): Observable<R> {\r\n        return this.single$.pipe(map(mapFn));\r\n    }\r\n\r\n    /**\r\n     * @description\r\n     * Returns a multiple-result Observable after applying the map function.\r\n     */\r\n    mapStream<R>(mapFn: (item: T) => R): Observable<R> {\r\n        return this.stream$.pipe(map(mapFn));\r\n    }\r\n}\r\n"]}

package/esm2020/core/data/server-config.mjs

@@ -0,0 +1,74 @@
+import { Injectable } from '@angular/core';
+import { lastValueFrom } from 'rxjs';
+import { GET_GLOBAL_SETTINGS, GET_SERVER_CONFIG } from './definitions/settings-definitions';
+import { BaseDataService } from './providers/base-data.service';
+import * as i0 from "@angular/core";
+export function initializeServerConfigService(serverConfigService) {
+    return serverConfigService.init();
+}
+/**
+ * A service which fetches the config from the server upon initialization, and then provides that config
+ * to the components which require it.
+ */
+export class ServerConfigService {
+    constructor(injector) {
+        this.injector = injector;
+        this._serverConfig = {};
+    }
+    get baseDataService() {
+        return this.injector.get(BaseDataService);
+    }
+    /**
+     * Fetches the ServerConfig. Should be run as part of the app bootstrap process by attaching
+     * to the Angular APP_INITIALIZER token.
+     */
+    init() {
+        return () => this.getServerConfig();
+    }
+    /**
+     * Fetch the ServerConfig. Should be run on app init (in case user is already logged in) and on successful login.
+     */
+    getServerConfig() {
+        return lastValueFrom(this.baseDataService.query(GET_SERVER_CONFIG).single$).then(result => {
+            this._serverConfig = result.globalSettings.serverConfig;
+        }, err => {
+            // Let the error fall through to be caught by the http interceptor.
+        });
+    }
+    getAvailableLanguages() {
+        return this.baseDataService
+            .query(GET_GLOBAL_SETTINGS, {}, 'cache-first')
+            .mapSingle(res => res.globalSettings.availableLanguages);
+    }
+    /**
+     * When any of the GlobalSettings are modified, this method should be called to update the Apollo cache.
+     */
+    refreshGlobalSettings() {
+        return this.baseDataService.query(GET_GLOBAL_SETTINGS, {}, 'network-only')
+            .single$;
+    }
+    /**
+     * Retrieves the custom field configs for the given entity type.
+     */
+    getCustomFieldsFor(type) {
+        return this.serverConfig.customFieldConfig[type] || [];
+    }
+    getOrderProcessStates() {
+        return this.serverConfig.orderProcess;
+    }
+    getPermittedAssetTypes() {
+        return this.serverConfig.permittedAssetTypes;
+    }
+    getPermissionDefinitions() {
+        return this.serverConfig.permissions;
+    }
+    get serverConfig() {
+        return this._serverConfig;
+    }
+}
+ServerConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ServerConfigService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+ServerConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ServerConfigService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ServerConfigService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/data/utils/add-custom-fields.mjs

@@ -0,0 +1,84 @@
+import { Kind, } from 'graphql';
+/**
+ * Given a GraphQL AST (DocumentNode), this function looks for fragment definitions and adds and configured
+ * custom fields to those fragments.
+ */
+export function addCustomFields(documentNode, customFields) {
+    const fragmentDefs = documentNode.definitions.filter(isFragmentDefinition);
+    for (const fragmentDef of fragmentDefs) {
+        let entityType = fragmentDef.typeCondition.name.value;
+        if (entityType === 'OrderAddress') {
+            // OrderAddress is a special case of the Address entity, and shares its custom fields
+            // so we treat it as an alias
+            entityType = 'Address';
+        }
+        const customFieldsForType = customFields[entityType];
+        if (customFieldsForType && customFieldsForType.length) {
+            fragmentDef.selectionSet.selections.push({
+                name: {
+                    kind: Kind.NAME,
+                    value: 'customFields',
+                },
+                kind: Kind.FIELD,
+                selectionSet: {
+                    kind: Kind.SELECTION_SET,
+                    selections: customFieldsForType.map(customField => {
+                        return {
+                            kind: Kind.FIELD,
+                            name: {
+                                kind: Kind.NAME,
+                                value: customField.name,
+                            },
+                            // For "relation" custom fields, we need to also select
+                            // all the scalar fields of the related type
+                            ...(customField.type === 'relation'
+                                ? {
+                                    selectionSet: {
+                                        kind: Kind.SELECTION_SET,
+                                        selections: customField.scalarFields.map(f => ({
+                                            kind: Kind.FIELD,
+                                            name: { kind: Kind.NAME, value: f },
+                                        })),
+                                    },
+                                }
+                                : {}),
+                        };
+                    }),
+                },
+            });
+            const localeStrings = customFieldsForType.filter(field => field.type === 'localeString');
+            const translationsField = fragmentDef.selectionSet.selections
+                .filter(isFieldNode)
+                .find(field => field.name.value === 'translations');
+            if (localeStrings.length && translationsField && translationsField.selectionSet) {
+                translationsField.selectionSet.selections.push({
+                    name: {
+                        kind: Kind.NAME,
+                        value: 'customFields',
+                    },
+                    kind: Kind.FIELD,
+                    selectionSet: {
+                        kind: Kind.SELECTION_SET,
+                        selections: localeStrings.map(customField => {
+                            return {
+                                kind: Kind.FIELD,
+                                name: {
+                                    kind: Kind.NAME,
+                                    value: customField.name,
+                                },
+                            };
+                        }),
+                    },
+                });
+            }
+        }
+    }
+    return documentNode;
+}
+function isFragmentDefinition(value) {
+    return value.kind === Kind.FRAGMENT_DEFINITION;
+}
+function isFieldNode(value) {
+    return value.kind === Kind.FIELD;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add-custom-fields.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/utils/add-custom-fields.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    DefinitionNode,\r\n    DocumentNode,\r\n    FieldNode,\r\n    FragmentDefinitionNode,\r\n    Kind,\r\n    SelectionNode,\r\n} from 'graphql';\r\n\r\nimport { CustomFields, RelationCustomFieldFragment } from '../../common/generated-types';\r\n\r\n/**\r\n * Given a GraphQL AST (DocumentNode), this function looks for fragment definitions and adds and configured\r\n * custom fields to those fragments.\r\n */\r\nexport function addCustomFields(documentNode: DocumentNode, customFields: CustomFields): DocumentNode {\r\n    const fragmentDefs = documentNode.definitions.filter(isFragmentDefinition);\r\n\r\n    for (const fragmentDef of fragmentDefs) {\r\n        let entityType = fragmentDef.typeCondition.name.value as keyof Pick<\r\n            CustomFields,\r\n            Exclude<keyof CustomFields, '__typename'>\r\n        >;\r\n\r\n        if (entityType === ('OrderAddress' as any)) {\r\n            // OrderAddress is a special case of the Address entity, and shares its custom fields\r\n            // so we treat it as an alias\r\n            entityType = 'Address';\r\n        }\r\n\r\n        const customFieldsForType = customFields[entityType];\r\n        if (customFieldsForType && customFieldsForType.length) {\r\n            (fragmentDef.selectionSet.selections as SelectionNode[]).push({\r\n                name: {\r\n                    kind: Kind.NAME,\r\n                    value: 'customFields',\r\n                },\r\n                kind: Kind.FIELD,\r\n                selectionSet: {\r\n                    kind: Kind.SELECTION_SET,\r\n                    selections: customFieldsForType.map(customField => {\r\n                        return {\r\n                            kind: Kind.FIELD,\r\n                            name: {\r\n                                kind: Kind.NAME,\r\n                                value: customField.name,\r\n                            },\r\n                            // For \"relation\" custom fields, we need to also select\r\n                            // all the scalar fields of the related type\r\n                            ...(customField.type === 'relation'\r\n                                ? {\r\n                                      selectionSet: {\r\n                                          kind: Kind.SELECTION_SET,\r\n                                          selections: (\r\n                                              customField as RelationCustomFieldFragment\r\n                                          ).scalarFields.map(f => ({\r\n                                              kind: Kind.FIELD,\r\n                                              name: { kind: Kind.NAME, value: f },\r\n                                          })),\r\n                                      },\r\n                                  }\r\n                                : {}),\r\n                        } as FieldNode;\r\n                    }),\r\n                },\r\n            });\r\n\r\n            const localeStrings = customFieldsForType.filter(field => field.type === 'localeString');\r\n\r\n            const translationsField = fragmentDef.selectionSet.selections\r\n                .filter(isFieldNode)\r\n                .find(field => field.name.value === 'translations');\r\n\r\n            if (localeStrings.length && translationsField && translationsField.selectionSet) {\r\n                (translationsField.selectionSet.selections as SelectionNode[]).push({\r\n                    name: {\r\n                        kind: Kind.NAME,\r\n                        value: 'customFields',\r\n                    },\r\n                    kind: Kind.FIELD,\r\n                    selectionSet: {\r\n                        kind: Kind.SELECTION_SET,\r\n                        selections: localeStrings.map(customField => {\r\n                            return {\r\n                                kind: Kind.FIELD,\r\n                                name: {\r\n                                    kind: Kind.NAME,\r\n                                    value: customField.name,\r\n                                },\r\n                            } as FieldNode;\r\n                        }),\r\n                    },\r\n                });\r\n            }\r\n        }\r\n    }\r\n\r\n    return documentNode;\r\n}\r\n\r\nfunction isFragmentDefinition(value: DefinitionNode): value is FragmentDefinitionNode {\r\n    return value.kind === Kind.FRAGMENT_DEFINITION;\r\n}\r\n\r\nfunction isFieldNode(value: SelectionNode): value is FieldNode {\r\n    return value.kind === Kind.FIELD;\r\n}\r\n"]}

package/esm2020/core/data/utils/transform-relation-custom-field-inputs.mjs

@@ -0,0 +1,46 @@
+import { getGraphQlInputName } from '@vendure/common/lib/shared-utils';
+/**
+ * Transforms any custom field "relation" type inputs into the corresponding `<name>Id` format,
+ * as expected by the server.
+ */
+export function transformRelationCustomFieldInputs(variables, customFieldConfig) {
+    if (variables.input) {
+        if (Array.isArray(variables.input)) {
+            for (const item of variables.input) {
+                transformRelations(item, customFieldConfig);
+            }
+        }
+        else {
+            transformRelations(variables.input, customFieldConfig);
+        }
+    }
+    return transformRelations(variables, customFieldConfig);
+}
+/**
+ * @description
+ * When persisting custom fields, we need to send just the IDs of the relations,
+ * rather than the objects themselves.
+ */
+function transformRelations(input, customFieldConfig) {
+    for (const field of customFieldConfig) {
+        if (field.type === 'relation') {
+            if (hasCustomFields(input)) {
+                const entityValue = input.customFields[field.name];
+                if (input.customFields.hasOwnProperty(field.name)) {
+                    delete input.customFields[field.name];
+                    input.customFields[getGraphQlInputName(field)] =
+                        field.list && Array.isArray(entityValue)
+                            ? entityValue.map(v => v?.id)
+                            : entityValue === null
+                                ? null
+                                : entityValue?.id;
+                }
+            }
+        }
+    }
+    return input;
+}
+function hasCustomFields(input) {
+    return input != null && input.hasOwnProperty('customFields') && typeof input.customFields === 'object';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/providers/auth/auth.service.mjs

@@ -0,0 +1,104 @@
+import { Injectable } from '@angular/core';
+import { DEFAULT_CHANNEL_CODE } from '@vendure/common/lib/shared-constants';
+import { of } from 'rxjs';
+import { catchError, map, mapTo, mergeMap, switchMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../local-storage/local-storage.service";
+import * as i2 from "../../data/providers/data.service";
+import * as i3 from "../../data/server-config";
+/**
+ * This service handles logic relating to authentication of the current user.
+ */
+export class AuthService {
+    constructor(localStorageService, dataService, serverConfigService) {
+        this.localStorageService = localStorageService;
+        this.dataService = dataService;
+        this.serverConfigService = serverConfigService;
+    }
+    /**
+     * Attempts to log in via the REST login endpoint and updates the app
+     * state on success.
+     */
+    logIn(username, password, rememberMe) {
+        return this.dataService.auth.attemptLogin(username, password, rememberMe).pipe(switchMap(response => {
+            if (response.login.__typename === 'CurrentUser') {
+                this.setChannelToken(response.login.channels);
+            }
+            return this.serverConfigService.getServerConfig().then(() => response.login);
+        }), switchMap(login => {
+            if (login.__typename === 'CurrentUser') {
+                const { id } = this.getActiveChannel(login.channels);
+                return this.dataService.client
+                    .loginSuccess(username, id, login.channels)
+                    .pipe(map(() => login));
+            }
+            return of(login);
+        }));
+    }
+    /**
+     * Update the user status to being logged out.
+     */
+    logOut() {
+        return this.dataService.client.userStatus().single$.pipe(switchMap(status => {
+            if (status.userStatus.isLoggedIn) {
+                return this.dataService.client
+                    .logOut()
+                    .pipe(mergeMap(() => this.dataService.auth.logOut()));
+            }
+            else {
+                return [];
+            }
+        }), mapTo(true));
+    }
+    /**
+     * Checks the app state to see if the user is already logged in,
+     * and if not, attempts to validate any auth token found.
+     */
+    checkAuthenticatedStatus() {
+        return this.dataService.client.userStatus().single$.pipe(mergeMap(data => {
+            if (!data.userStatus.isLoggedIn) {
+                return this.validateAuthToken();
+            }
+            else {
+                return of(true);
+            }
+        }));
+    }
+    /**
+     * Checks for an auth token and if found, attempts to validate
+     * that token against the API.
+     */
+    validateAuthToken() {
+        return this.dataService.auth.currentUser().single$.pipe(mergeMap(result => {
+            if (!result.me) {
+                return of(false);
+            }
+            this.setChannelToken(result.me.channels);
+            const { id } = this.getActiveChannel(result.me.channels);
+            return this.dataService.client.loginSuccess(result.me.identifier, id, result.me.channels);
+        }), mapTo(true), catchError(err => of(false)));
+    }
+    getActiveChannel(userChannels) {
+        const lastActiveChannelToken = this.localStorageService.get('activeChannelToken');
+        if (lastActiveChannelToken) {
+            const lastActiveChannel = userChannels.find(c => c.token === lastActiveChannelToken);
+            if (lastActiveChannel) {
+                return lastActiveChannel;
+            }
+        }
+        const defaultChannel = userChannels.find(c => c.code === DEFAULT_CHANNEL_CODE);
+        return defaultChannel || userChannels[0];
+    }
+    setChannelToken(userChannels) {
+        this.localStorageService.set('activeChannelToken', this.getActiveChannel(userChannels).token);
+    }
+}
+AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AuthService, deps: [{ token: i1.LocalStorageService }, { token: i2.DataService }, { token: i3.ServerConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LocalStorageService }, { type: i2.DataService }, { type: i3.ServerConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/auth/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { DEFAULT_CHANNEL_CODE } from '@vendure/common/lib/shared-constants';\r\nimport { Observable, of } from 'rxjs';\r\nimport { catchError, map, mapTo, mergeMap, switchMap } from 'rxjs/operators';\r\n\r\nimport { AttemptLoginMutation, CurrentUserFragment } from '../../common/generated-types';\r\nimport { DataService } from '../../data/providers/data.service';\r\nimport { ServerConfigService } from '../../data/server-config';\r\nimport { LocalStorageService } from '../local-storage/local-storage.service';\r\n\r\n/**\r\n * This service handles logic relating to authentication of the current user.\r\n */\r\n@Injectable({\r\n    providedIn: 'root',\r\n})\r\nexport class AuthService {\r\n    constructor(\r\n        private localStorageService: LocalStorageService,\r\n        private dataService: DataService,\r\n        private serverConfigService: ServerConfigService,\r\n    ) {}\r\n\r\n    /**\r\n     * Attempts to log in via the REST login endpoint and updates the app\r\n     * state on success.\r\n     */\r\n    logIn(\r\n        username: string,\r\n        password: string,\r\n        rememberMe: boolean,\r\n    ): Observable<AttemptLoginMutation['login']> {\r\n        return this.dataService.auth.attemptLogin(username, password, rememberMe).pipe(\r\n            switchMap(response => {\r\n                if (response.login.__typename === 'CurrentUser') {\r\n                    this.setChannelToken(response.login.channels);\r\n                }\r\n                return this.serverConfigService.getServerConfig().then(() => response.login);\r\n            }),\r\n            switchMap(login => {\r\n                if (login.__typename === 'CurrentUser') {\r\n                    const { id } = this.getActiveChannel(login.channels);\r\n                    return this.dataService.client\r\n                        .loginSuccess(username, id, login.channels)\r\n                        .pipe(map(() => login));\r\n                }\r\n                return of(login);\r\n            }),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Update the user status to being logged out.\r\n     */\r\n    logOut(): Observable<boolean> {\r\n        return this.dataService.client.userStatus().single$.pipe(\r\n            switchMap(status => {\r\n                if (status.userStatus.isLoggedIn) {\r\n                    return this.dataService.client\r\n                        .logOut()\r\n                        .pipe(mergeMap(() => this.dataService.auth.logOut()));\r\n                } else {\r\n                    return [];\r\n                }\r\n            }),\r\n            mapTo(true),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Checks the app state to see if the user is already logged in,\r\n     * and if not, attempts to validate any auth token found.\r\n     */\r\n    checkAuthenticatedStatus(): Observable<boolean> {\r\n        return this.dataService.client.userStatus().single$.pipe(\r\n            mergeMap(data => {\r\n                if (!data.userStatus.isLoggedIn) {\r\n                    return this.validateAuthToken();\r\n                } else {\r\n                    return of(true);\r\n                }\r\n            }),\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Checks for an auth token and if found, attempts to validate\r\n     * that token against the API.\r\n     */\r\n    validateAuthToken(): Observable<boolean> {\r\n        return this.dataService.auth.currentUser().single$.pipe(\r\n            mergeMap(result => {\r\n                if (!result.me) {\r\n                    return of(false) as any;\r\n                }\r\n                this.setChannelToken(result.me.channels);\r\n                const { id } = this.getActiveChannel(result.me.channels);\r\n                return this.dataService.client.loginSuccess(result.me.identifier, id, result.me.channels);\r\n            }),\r\n            mapTo(true),\r\n            catchError(err => of(false)),\r\n        );\r\n    }\r\n\r\n    private getActiveChannel(userChannels: CurrentUserFragment['channels']) {\r\n        const lastActiveChannelToken = this.localStorageService.get('activeChannelToken');\r\n        if (lastActiveChannelToken) {\r\n            const lastActiveChannel = userChannels.find(c => c.token === lastActiveChannelToken);\r\n            if (lastActiveChannel) {\r\n                return lastActiveChannel;\r\n            }\r\n        }\r\n        const defaultChannel = userChannels.find(c => c.code === DEFAULT_CHANNEL_CODE);\r\n        return defaultChannel || userChannels[0];\r\n    }\r\n\r\n    private setChannelToken(userChannels: CurrentUserFragment['channels']) {\r\n        this.localStorageService.set('activeChannelToken', this.getActiveChannel(userChannels).token);\r\n    }\r\n}\r\n"]}

package/esm2020/core/providers/component-registry/component-registry.service.mjs

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ComponentRegistryService {
+    constructor() {
+        this.inputComponentMap = new Map();
+    }
+    registerInputComponent(id, component) {
+        if (this.inputComponentMap.has(id)) {
+            throw new Error(`Cannot register an InputComponent with the id "${id}", as one with that id already exists`);
+        }
+        this.inputComponentMap.set(id, component);
+    }
+    getInputComponent(id) {
+        return this.inputComponentMap.get(id);
+    }
+}
+ComponentRegistryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ComponentRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ComponentRegistryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ComponentRegistryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ComponentRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/providers/custom-detail-component/custom-detail-component.service.mjs

@@ -0,0 +1,44 @@
+import { APP_INITIALIZER, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * Registers a {@link CustomDetailComponent} to be placed in a given location. This allows you
+ * to embed any type of custom Angular component in the entity detail pages of the Admin UI.
+ *
+ * @docsCategory custom-detail-components
+ */
+export function registerCustomDetailComponent(config) {
+    return {
+        provide: APP_INITIALIZER,
+        multi: true,
+        useFactory: (customDetailComponentService) => () => {
+            customDetailComponentService.registerCustomDetailComponent(config);
+        },
+        deps: [CustomDetailComponentService],
+    };
+}
+export class CustomDetailComponentService {
+    constructor() {
+        this.customDetailComponents = new Map();
+    }
+    registerCustomDetailComponent(config) {
+        if (this.customDetailComponents.has(config.locationId)) {
+            this.customDetailComponents.get(config.locationId)?.push(config);
+        }
+        else {
+            this.customDetailComponents.set(config.locationId, [config]);
+        }
+    }
+    getCustomDetailComponentsFor(locationId) {
+        return this.customDetailComponents.get(locationId) ?? [];
+    }
+}
+CustomDetailComponentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CustomDetailComponentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CustomDetailComponentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CustomDetailComponentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CustomDetailComponentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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