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

package/{esm2015/core/data/utils/remove-readonly-custom-fields.js → esm2020/core/data/utils/remove-readonly-custom-fields.mjs}

@@ -85,4 +85,4 @@ function hasCustomFields(input) {
 function hasTranslations(input) {
     return input != null && input.hasOwnProperty('translations');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remove-readonly-custom-fields.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/utils/remove-readonly-custom-fields.ts"],"names":[],"mappings":"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","sourcesContent":["import { simpleDeepClone } from '@vendure/common/lib/simple-deep-clone';\nimport { DocumentNode, getOperationAST, NamedTypeNode, TypeNode } from 'graphql';\n\nimport { CustomFieldConfig } from '../../common/generated-types';\n\nconst CREATE_ENTITY_REGEX = /Create([A-Za-z]+)Input/;\nconst UPDATE_ENTITY_REGEX = /Update([A-Za-z]+)Input/;\n\ntype InputWithOptionalCustomFields = Record<string, any> & {\n    customFields?: Record<string, any>;\n};\ntype InputWithCustomFields = Record<string, any> & {\n    customFields: Record<string, any>;\n};\n\ntype EntityInput = InputWithOptionalCustomFields & {\n    translations?: InputWithOptionalCustomFields[];\n};\n\n/**\n * Checks the current documentNode for an operation with a variable named \"Create<Entity>Input\" or \"Update<Entity>Input\"\n * and if a match is found, returns the <Entity> name.\n */\nexport function isEntityCreateOrUpdateMutation(documentNode: DocumentNode): string | undefined {\n    const operationDef = getOperationAST(documentNode, null);\n    if (operationDef && operationDef.variableDefinitions) {\n        for (const variableDef of operationDef.variableDefinitions) {\n            const namedType = extractInputType(variableDef.type);\n            const inputTypeName = namedType.name.value;\n\n            // special cases which don't follow the usual pattern\n            if (inputTypeName === 'UpdateActiveAdministratorInput') {\n                return 'Administrator';\n            }\n\n            const createMatch = inputTypeName.match(CREATE_ENTITY_REGEX);\n            if (createMatch) {\n                return createMatch[1];\n            }\n            const updateMatch = inputTypeName.match(UPDATE_ENTITY_REGEX);\n            if (updateMatch) {\n                return updateMatch[1];\n            }\n        }\n    }\n}\n\nfunction extractInputType(type: TypeNode): NamedTypeNode {\n    if (type.kind === 'NonNullType') {\n        return extractInputType(type.type);\n    }\n    if (type.kind === 'ListType') {\n        return extractInputType(type.type);\n    }\n    return type;\n}\n\n/**\n * Removes any `readonly` custom fields from an entity (including its translations).\n * To be used before submitting the entity for a create or update request.\n */\nexport function removeReadonlyCustomFields(\n    variables: { input?: EntityInput | EntityInput[] } | EntityInput | EntityInput[],\n    customFieldConfig: CustomFieldConfig[],\n): { input?: EntityInput | EntityInput[] } | EntityInput | EntityInput[] {\n    if (!Array.isArray(variables)) {\n        if (Array.isArray(variables.input)) {\n            for (const input of variables.input) {\n                removeReadonly(input, customFieldConfig);\n            }\n        } else {\n            removeReadonly(variables.input, customFieldConfig);\n        }\n    } else {\n        for (const input of variables) {\n            removeReadonly(input, customFieldConfig);\n        }\n    }\n    return removeReadonly(variables, customFieldConfig);\n}\n\nfunction removeReadonly(input: InputWithOptionalCustomFields, customFieldConfig: CustomFieldConfig[]) {\n    for (const field of customFieldConfig) {\n        if (field.readonly) {\n            if (field.type === 'localeString') {\n                if (hasTranslations(input)) {\n                    for (const translation of input.translations) {\n                        if (\n                            hasCustomFields(translation) &&\n                            translation.customFields[field.name] !== undefined\n                        ) {\n                            delete translation.customFields[field.name];\n                        }\n                    }\n                }\n            } else {\n                if (hasCustomFields(input) && input.customFields[field.name] !== undefined) {\n                    delete input.customFields[field.name];\n                }\n            }\n        }\n    }\n    return input;\n}\n\nfunction hasCustomFields(input: any): input is InputWithCustomFields {\n    return input != null && input.hasOwnProperty('customFields');\n}\n\nfunction hasTranslations(input: any): input is { translations: InputWithOptionalCustomFields[] } {\n    return input != null && input.hasOwnProperty('translations');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remove-readonly-custom-fields.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/utils/remove-readonly-custom-fields.ts"],"names":[],"mappings":"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","sourcesContent":["import { simpleDeepClone } from '@vendure/common/lib/simple-deep-clone';\r\nimport { DocumentNode, getOperationAST, NamedTypeNode, TypeNode } from 'graphql';\r\n\r\nimport { CustomFieldConfig } from '../../common/generated-types';\r\n\r\nconst CREATE_ENTITY_REGEX = /Create([A-Za-z]+)Input/;\r\nconst UPDATE_ENTITY_REGEX = /Update([A-Za-z]+)Input/;\r\n\r\ntype InputWithOptionalCustomFields = Record<string, any> & {\r\n    customFields?: Record<string, any>;\r\n};\r\ntype InputWithCustomFields = Record<string, any> & {\r\n    customFields: Record<string, any>;\r\n};\r\n\r\ntype EntityInput = InputWithOptionalCustomFields & {\r\n    translations?: InputWithOptionalCustomFields[];\r\n};\r\n\r\n/**\r\n * Checks the current documentNode for an operation with a variable named \"Create<Entity>Input\" or \"Update<Entity>Input\"\r\n * and if a match is found, returns the <Entity> name.\r\n */\r\nexport function isEntityCreateOrUpdateMutation(documentNode: DocumentNode): string | undefined {\r\n    const operationDef = getOperationAST(documentNode, null);\r\n    if (operationDef && operationDef.variableDefinitions) {\r\n        for (const variableDef of operationDef.variableDefinitions) {\r\n            const namedType = extractInputType(variableDef.type);\r\n            const inputTypeName = namedType.name.value;\r\n\r\n            // special cases which don't follow the usual pattern\r\n            if (inputTypeName === 'UpdateActiveAdministratorInput') {\r\n                return 'Administrator';\r\n            }\r\n\r\n            const createMatch = inputTypeName.match(CREATE_ENTITY_REGEX);\r\n            if (createMatch) {\r\n                return createMatch[1];\r\n            }\r\n            const updateMatch = inputTypeName.match(UPDATE_ENTITY_REGEX);\r\n            if (updateMatch) {\r\n                return updateMatch[1];\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nfunction extractInputType(type: TypeNode): NamedTypeNode {\r\n    if (type.kind === 'NonNullType') {\r\n        return extractInputType(type.type);\r\n    }\r\n    if (type.kind === 'ListType') {\r\n        return extractInputType(type.type);\r\n    }\r\n    return type;\r\n}\r\n\r\n/**\r\n * Removes any `readonly` custom fields from an entity (including its translations).\r\n * To be used before submitting the entity for a create or update request.\r\n */\r\nexport function removeReadonlyCustomFields(\r\n    variables: { input?: EntityInput | EntityInput[] } | EntityInput | EntityInput[],\r\n    customFieldConfig: CustomFieldConfig[],\r\n): { input?: EntityInput | EntityInput[] } | EntityInput | EntityInput[] {\r\n    if (!Array.isArray(variables)) {\r\n        if (Array.isArray(variables.input)) {\r\n            for (const input of variables.input) {\r\n                removeReadonly(input, customFieldConfig);\r\n            }\r\n        } else {\r\n            removeReadonly(variables.input, customFieldConfig);\r\n        }\r\n    } else {\r\n        for (const input of variables) {\r\n            removeReadonly(input, customFieldConfig);\r\n        }\r\n    }\r\n    return removeReadonly(variables, customFieldConfig);\r\n}\r\n\r\nfunction removeReadonly(input: InputWithOptionalCustomFields, customFieldConfig: CustomFieldConfig[]) {\r\n    for (const field of customFieldConfig) {\r\n        if (field.readonly) {\r\n            if (field.type === 'localeString') {\r\n                if (hasTranslations(input)) {\r\n                    for (const translation of input.translations) {\r\n                        if (\r\n                            hasCustomFields(translation) &&\r\n                            translation.customFields[field.name] !== undefined\r\n                        ) {\r\n                            delete translation.customFields[field.name];\r\n                        }\r\n                    }\r\n                }\r\n            } else {\r\n                if (hasCustomFields(input) && input.customFields[field.name] !== undefined) {\r\n                    delete input.customFields[field.name];\r\n                }\r\n            }\r\n        }\r\n    }\r\n    return input;\r\n}\r\n\r\nfunction hasCustomFields(input: any): input is InputWithCustomFields {\r\n    return input != null && input.hasOwnProperty('customFields');\r\n}\r\n\r\nfunction hasTranslations(input: any): input is { translations: InputWithOptionalCustomFields[] } {\r\n    return input != null && input.hasOwnProperty('translations');\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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

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

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../component-registry/component-registry.service";
+/**
+ * This service allows the registration of custom controls for customFields.
+ *
+ * @deprecated The ComponentRegistryService now handles custom field components directly.
+ */
+export class CustomFieldComponentService {
+    constructor(componentRegistryService) {
+        this.componentRegistryService = componentRegistryService;
+    }
+    /**
+     * Register a CustomFieldControl component to be used with the specified customField and entity.
+     */
+    registerCustomFieldComponent(entity, fieldName, component) {
+        const id = this.generateId(entity, fieldName, true);
+        this.componentRegistryService.registerInputComponent(id, component);
+    }
+    /**
+     * Checks whether a custom component is registered for the given entity custom field,
+     * and if so returns the ID of that component.
+     */
+    customFieldComponentExists(entity, fieldName) {
+        const id = this.generateId(entity, fieldName, true);
+        return this.componentRegistryService.getInputComponent(id) ? id : undefined;
+    }
+    generateId(entity, fieldName, isCustomField) {
+        let id = entity;
+        if (isCustomField) {
+            id += '-customFields';
+        }
+        id += '-' + fieldName;
+        return id;
+    }
+}
+CustomFieldComponentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CustomFieldComponentService, deps: [{ token: i1.ComponentRegistryService }], target: i0.ɵɵFactoryTarget.Injectable });
+CustomFieldComponentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CustomFieldComponentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: CustomFieldComponentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ComponentRegistryService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/providers/dashboard-widget/dashboard-widget.service.mjs

@@ -0,0 +1,98 @@
+import { Injectable } from '@angular/core';
+import { notNullOrUndefined } from '@vendure/common/lib/shared-utils';
+import * as i0 from "@angular/core";
+/**
+ * Responsible for registering dashboard widget components and querying for layouts.
+ */
+export class DashboardWidgetService {
+    constructor() {
+        this.registry = new Map();
+        this.layoutDef = [];
+    }
+    registerWidget(id, config) {
+        if (this.registry.has(id)) {
+            throw new Error(`A dashboard widget with the id "${id}" already exists`);
+        }
+        this.registry.set(id, config);
+    }
+    getAvailableIds(currentUserPermissions) {
+        const hasAllPermissions = (requiredPerms, userPerms) => {
+            return requiredPerms.every(p => userPerms.includes(p));
+        };
+        return [...this.registry.entries()]
+            .filter(([id, config]) => {
+            return (!config.requiresPermissions ||
+                hasAllPermissions(config.requiresPermissions, currentUserPermissions));
+        })
+            .map(([id]) => id);
+    }
+    getWidgetById(id) {
+        if (!this.registry.has(id)) {
+            throw new Error(`No widget was found with the id "${id}"`);
+        }
+        return this.registry.get(id);
+    }
+    setDefaultLayout(layout) {
+        this.layoutDef = layout;
+    }
+    getDefaultLayout() {
+        return this.layoutDef;
+    }
+    getWidgetLayout(layoutDef) {
+        const intermediateLayout = (layoutDef || this.layoutDef)
+            .map(({ id, width }) => {
+            const config = this.registry.get(id);
+            if (!config) {
+                return this.idNotFound(id);
+            }
+            return { id, config, width: this.getValidWidth(id, config, width) };
+        })
+            .filter(notNullOrUndefined);
+        return this.buildLayout(intermediateLayout);
+    }
+    idNotFound(id) {
+        // tslint:disable-next-line:no-console
+        console.error(`No dashboard widget was found with the id "${id}"\nAvailable ids: ${[...this.registry.keys()]
+            .map(_id => `"${_id}"`)
+            .join(', ')}`);
+        return;
+    }
+    getValidWidth(id, config, targetWidth) {
+        let adjustedWidth = targetWidth;
+        const supportedWidths = config.supportedWidths?.length
+            ? config.supportedWidths
+            : [3, 4, 6, 8, 12];
+        if (!supportedWidths.includes(targetWidth)) {
+            // Fall back to the largest supported width
+            const sortedWidths = supportedWidths.sort((a, b) => a - b);
+            const fallbackWidth = supportedWidths[sortedWidths.length - 1];
+            // tslint:disable-next-line:no-console
+            console.error(`The "${id}" widget does not support the specified width (${targetWidth}).\nSupported widths are: [${sortedWidths.join(', ')}].\nUsing (${fallbackWidth}) instead.`);
+            adjustedWidth = fallbackWidth;
+        }
+        return adjustedWidth;
+    }
+    buildLayout(intermediateLayout) {
+        const layout = [];
+        let row = [];
+        for (const { id, config, width } of intermediateLayout) {
+            const rowSize = row.reduce((size, c) => size + c.width, 0);
+            if (12 < rowSize + width) {
+                layout.push(row);
+                row = [];
+            }
+            row.push({ id, config, width });
+        }
+        layout.push(row);
+        return layout;
+    }
+}
+DashboardWidgetService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DashboardWidgetService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DashboardWidgetService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DashboardWidgetService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: DashboardWidgetService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard-widget.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/dashboard-widget/dashboard-widget.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { notNullOrUndefined } from '@vendure/common/lib/shared-utils';\n\nimport { Permission } from '../../common/generated-types';\n\nimport {\n    DashboardWidgetConfig,\n    DashboardWidgetWidth,\n    WidgetLayout,\n    WidgetLayoutDefinition,\n} from './dashboard-widget-types';\n\n/**\n * Responsible for registering dashboard widget components and querying for layouts.\n */\n@Injectable({\n    providedIn: 'root',\n})\nexport class DashboardWidgetService {\n    private registry = new Map<string, DashboardWidgetConfig>();\n    private layoutDef: WidgetLayoutDefinition = [];\n\n    registerWidget(id: string, config: DashboardWidgetConfig) {\n        if (this.registry.has(id)) {\n            throw new Error(`A dashboard widget with the id \"${id}\" already exists`);\n        }\n\n        this.registry.set(id, config);\n    }\n\n    getAvailableIds(currentUserPermissions: Permission[]): string[] {\n        const hasAllPermissions = (requiredPerms: string[], userPerms: string[]): boolean => {\n            return requiredPerms.every(p => userPerms.includes(p));\n        };\n\n        return [...this.registry.entries()]\n            .filter(([id, config]) => {\n                return (\n                    !config.requiresPermissions ||\n                    hasAllPermissions(config.requiresPermissions, currentUserPermissions)\n                );\n            })\n            .map(([id]) => id);\n    }\n\n    getWidgetById(id: string) {\n        if (!this.registry.has(id)) {\n            throw new Error(`No widget was found with the id \"${id}\"`);\n        }\n        return this.registry.get(id);\n    }\n\n    setDefaultLayout(layout: WidgetLayoutDefinition) {\n        this.layoutDef = layout;\n    }\n\n    getDefaultLayout(): WidgetLayoutDefinition {\n        return this.layoutDef;\n    }\n\n    getWidgetLayout(layoutDef?: WidgetLayoutDefinition): WidgetLayout {\n        const intermediateLayout = (layoutDef || this.layoutDef)\n            .map(({ id, width }) => {\n                const config = this.registry.get(id);\n                if (!config) {\n                    return this.idNotFound(id);\n                }\n                return { id, config, width: this.getValidWidth(id, config, width) };\n            })\n            .filter(notNullOrUndefined);\n\n        return this.buildLayout(intermediateLayout);\n    }\n\n    private idNotFound(id: string): undefined {\n        // tslint:disable-next-line:no-console\n        console.error(\n            `No dashboard widget was found with the id \"${id}\"\\nAvailable ids: ${[...this.registry.keys()]\n                .map(_id => `\"${_id}\"`)\n                .join(', ')}`,\n        );\n        return;\n    }\n\n    private getValidWidth(\n        id: string,\n        config: DashboardWidgetConfig,\n        targetWidth: DashboardWidgetWidth,\n    ): DashboardWidgetWidth {\n        let adjustedWidth = targetWidth;\n        const supportedWidths = config.supportedWidths?.length\n            ? config.supportedWidths\n            : ([3, 4, 6, 8, 12] as DashboardWidgetWidth[]);\n        if (!supportedWidths.includes(targetWidth)) {\n            // Fall back to the largest supported width\n            const sortedWidths = supportedWidths.sort((a, b) => a - b);\n            const fallbackWidth = supportedWidths[sortedWidths.length - 1];\n            // tslint:disable-next-line:no-console\n            console.error(\n                `The \"${id}\" widget does not support the specified width (${targetWidth}).\\nSupported widths are: [${sortedWidths.join(\n                    ', ',\n                )}].\\nUsing (${fallbackWidth}) instead.`,\n            );\n            adjustedWidth = fallbackWidth;\n        }\n        return adjustedWidth;\n    }\n\n    private buildLayout(intermediateLayout: WidgetLayout[number]): WidgetLayout {\n        const layout: WidgetLayout = [];\n        let row: WidgetLayout[number] = [];\n        for (const { id, config, width } of intermediateLayout) {\n            const rowSize = row.reduce((size, c) => size + c.width, 0);\n            if (12 < rowSize + width) {\n                layout.push(row);\n                row = [];\n            }\n            row.push({ id, config, width });\n        }\n        layout.push(row);\n        return layout;\n    }\n}\n"]}

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

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

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

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

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

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