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

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":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;;AAWtE;;GAEG;AAIH,MAAM,OAAO,sBAAsB;IAHnC;QAIY,aAAQ,GAAG,IAAI,GAAG,EAAiC,CAAC;QACpD,cAAS,GAA2B,EAAE,CAAC;KAsGlD;IApGG,cAAc,CAAC,EAAU,EAAE,MAA6B;QACpD,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;YACvB,MAAM,IAAI,KAAK,CAAC,mCAAmC,EAAE,kBAAkB,CAAC,CAAC;SAC5E;QAED,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAClC,CAAC;IAED,eAAe,CAAC,sBAAoC;QAChD,MAAM,iBAAiB,GAAG,CAAC,aAAuB,EAAE,SAAmB,EAAW,EAAE;YAChF,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3D,CAAC,CAAC;QAEF,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;aAC9B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE;YACrB,OAAO,CACH,CAAC,MAAM,CAAC,mBAAmB;gBAC3B,iBAAiB,CAAC,MAAM,CAAC,mBAAmB,EAAE,sBAAsB,CAAC,CACxE,CAAC;QACN,CAAC,CAAC;aACD,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;IAC3B,CAAC;IAED,aAAa,CAAC,EAAU;QACpB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,oCAAoC,EAAE,GAAG,CAAC,CAAC;SAC9D;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACjC,CAAC;IAED,gBAAgB,CAAC,MAA8B;QAC3C,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC;IAC5B,CAAC;IAED,gBAAgB;QACZ,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED,eAAe,CAAC,SAAkC;QAC9C,MAAM,kBAAkB,GAAG,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC;aACnD,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;YACnB,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACrC,IAAI,CAAC,MAAM,EAAE;gBACT,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;aAC9B;YACD,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC;QACxE,CAAC,CAAC;aACD,MAAM,CAAC,kBAAkB,CAAC,CAAC;QAEhC,OAAO,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,CAAC;IAChD,CAAC;IAEO,UAAU,CAAC,EAAU;QACzB,sCAAsC;QACtC,OAAO,CAAC,KAAK,CACT,8CAA8C,EAAE,qBAAqB,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;aACzF,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,GAAG,CAAC;aACtB,IAAI,CAAC,IAAI,CAAC,EAAE,CACpB,CAAC;QACF,OAAO;IACX,CAAC;IAEO,aAAa,CACjB,EAAU,EACV,MAA6B,EAC7B,WAAiC;QAEjC,IAAI,aAAa,GAAG,WAAW,CAAC;QAChC,MAAM,eAAe,GAAG,MAAM,CAAC,eAAe,EAAE,MAAM;YAClD,CAAC,CAAC,MAAM,CAAC,eAAe;YACxB,CAAC,CAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAA4B,CAAC;QACnD,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;YACxC,2CAA2C;YAC3C,MAAM,YAAY,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAC3D,MAAM,aAAa,GAAG,eAAe,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAC/D,sCAAsC;YACtC,OAAO,CAAC,KAAK,CACT,QAAQ,EAAE,kDAAkD,WAAW,8BAA8B,YAAY,CAAC,IAAI,CAClH,IAAI,CACP,cAAc,aAAa,YAAY,CAC3C,CAAC;YACF,aAAa,GAAG,aAAa,CAAC;SACjC;QACD,OAAO,aAAa,CAAC;IACzB,CAAC;IAEO,WAAW,CAAC,kBAAwC;QACxD,MAAM,MAAM,GAAiB,EAAE,CAAC;QAChC,IAAI,GAAG,GAAyB,EAAE,CAAC;QACnC,KAAK,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,kBAAkB,EAAE;YACpD,MAAM,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAC3D,IAAI,EAAE,GAAG,OAAO,GAAG,KAAK,EAAE;gBACtB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACjB,GAAG,GAAG,EAAE,CAAC;aACZ;YACD,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;SACnC;QACD,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjB,OAAO,MAAM,CAAC;IAClB,CAAC;;mHAvGQ,sBAAsB;uHAAtB,sBAAsB,cAFnB,MAAM;2FAET,sBAAsB;kBAHlC,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLW1lc3NhZ2UtZm9ybWF0LWNvbXBpbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9jb3JlL3NyYy9wcm92aWRlcnMvaTE4bi9jdXN0b20tbWVzc2FnZS1mb3JtYXQtY29tcGlsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0JBQStCO0FBQy9CLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUNILDhCQUE4QixHQUVqQyxNQUFNLHNDQUFzQyxDQUFDOztBQUU5Qzs7Ozs7OztHQU9HO0FBRUgsTUFBTSxPQUFPLHdDQUF5QyxTQUFRLDhCQUE4QjtJQUN4RixtQkFBbUIsQ0FBQyxLQUFVLEVBQUUsSUFBWTtRQUN4QyxJQUFJO1lBQ0EsT0FBTyxLQUFLLENBQUMsbUJBQW1CLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxDQUFDO1NBQ2pEO1FBQUMsT0FBTyxDQUFNLEVBQUU7WUFDYixPQUFPLENBQUMsS0FBSyxDQUFDLCtCQUErQixJQUFJLGdCQUFnQixDQUFDLENBQUM7WUFDbkUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNmLE9BQU8sQ0FBQyxHQUFHLENBQ1Asd0ZBQXdGLENBQzNGLENBQUM7U0FDTDtJQUNMLENBQUM7O3FJQVhRLHdDQUF3Qzt5SUFBeEMsd0NBQXdDLGNBRDNCLE1BQU07MkZBQ25CLHdDQUF3QztrQkFEcEQsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyIvKiB0c2xpbnQ6ZGlzYWJsZTpuby1jb25zb2xlICovXHJcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHtcclxuICAgIFRyYW5zbGF0ZU1lc3NhZ2VGb3JtYXRDb21waWxlcixcclxuICAgIFRyYW5zbGF0ZU1lc3NhZ2VGb3JtYXREZWJ1Z0NvbXBpbGVyLFxyXG59IGZyb20gJ25neC10cmFuc2xhdGUtbWVzc2FnZWZvcm1hdC1jb21waWxlcic7XHJcblxyXG4vKipcclxuICogV29yay1hcm91bmQgZm9yIEFuZ3VsYXIgOSBjb21wYXQuXHJcbiAqIFNlZSBodHRwczovL2dpdGh1Yi5jb20vbGVwaHlydXMvbmd4LXRyYW5zbGF0ZS1tZXNzYWdlZm9ybWF0LWNvbXBpbGVyL2lzc3Vlcy81MyNpc3N1ZWNvbW1lbnQtNTgzNjc3OTk0XHJcbiAqXHJcbiAqIEFsc28gbG9ncyBlcnJvcnMgd2hpY2ggd291bGQgb3RoZXJ3aXNlIGdldCBzd2FsbG93ZWQgYnkgbmd4LXRyYW5zbGF0ZS4gVGhpcyBpcyBpbXBvcnRhbnRcclxuICogYmVjYXVzZSBpdCBpcyBxdWl0ZSBlYXN5IHRvIG1ha2UgZXJyb3JzIGluIG1lc3NhZ2Vmb3JtYXQgc3ludGF4LCBhbmQgd2l0aG91dCBjbGVhclxyXG4gKiBlcnJvciBtZXNzYWdlcyBpdCdzIHZlcnkgaGFyZCB0byBkZWJ1Zy5cclxuICovXHJcbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXHJcbmV4cG9ydCBjbGFzcyBJbmplY3RhYmxlVHJhbnNsYXRlTWVzc2FnZUZvcm1hdENvbXBpbGVyIGV4dGVuZHMgVHJhbnNsYXRlTWVzc2FnZUZvcm1hdENvbXBpbGVyIHtcclxuICAgIGNvbXBpbGVUcmFuc2xhdGlvbnModmFsdWU6IGFueSwgbGFuZzogc3RyaW5nKTogYW55IHtcclxuICAgICAgICB0cnkge1xyXG4gICAgICAgICAgICByZXR1cm4gc3VwZXIuY29tcGlsZVRyYW5zbGF0aW9ucyh2YWx1ZSwgbGFuZyk7XHJcbiAgICAgICAgfSBjYXRjaCAoZTogYW55KSB7XHJcbiAgICAgICAgICAgIGNvbnNvbGUuZXJyb3IoYFRoZXJlIHdhcyBhbiBlcnJvciB3aXRoIHRoZSAke2xhbmd9IHRyYW5zbGF0aW9uczpgKTtcclxuICAgICAgICAgICAgY29uc29sZS5sb2coZSk7XHJcbiAgICAgICAgICAgIGNvbnNvbGUubG9nKFxyXG4gICAgICAgICAgICAgICAgYENoZWNrIHRoZSBtZXNzYWdlZm9ybWF0IGRvY3M6IGh0dHBzOi8vbWVzc2FnZWZvcm1hdC5naXRodWIuaW8vbWVzc2FnZWZvcm1hdC9wYWdlLWd1aWRlYCxcclxuICAgICAgICAgICAgKTtcclxuICAgICAgICB9XHJcbiAgICB9XHJcbn1cclxuIl19

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

@@ -0,0 +1,54 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+/** @dynamic */
+export class I18nService {
+    constructor(ngxTranslate, document) {
+        this.ngxTranslate = ngxTranslate;
+        this.document = document;
+        this._availableLanguages = [];
+    }
+    get availableLanguages() {
+        return [...this._availableLanguages];
+    }
+    /**
+     * Set the default language
+     */
+    setDefaultLanguage(languageCode) {
+        this.ngxTranslate.setDefaultLang(languageCode);
+    }
+    /**
+     * Set the UI language
+     */
+    setLanguage(language) {
+        this.ngxTranslate.use(language);
+        if (this.document?.documentElement) {
+            this.document.documentElement.lang = language;
+        }
+    }
+    /**
+     * Set the available UI languages
+     */
+    setAvailableLanguages(languages) {
+        this._availableLanguages = languages;
+    }
+    /**
+     * Translate the given key.
+     */
+    translate(key, params) {
+        return this.ngxTranslate.instant(key, params);
+    }
+}
+I18nService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: I18nService, deps: [{ token: i1.TranslateService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+I18nService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: I18nService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: I18nService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/providers/job-queue/job-queue.service.mjs

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import { EMPTY, interval, of, Subject, timer } from 'rxjs';
+import { debounceTime, map, mapTo, scan, shareReplay, switchMap } from 'rxjs/operators';
+import { JobState, Permission } from '../../common/generated-types';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+export class JobQueueService {
+    constructor(dataService) {
+        this.dataService = dataService;
+        this.updateJob$ = new Subject();
+        this.onCompleteHandlers = new Map();
+        this.checkForJobs();
+        this.activeJobs$ = this.updateJob$.pipe(scan((jobMap, job) => this.handleJob(jobMap, job), new Map()), map(jobMap => Array.from(jobMap.values())), debounceTime(500), shareReplay(1));
+        this.subscription = this.activeJobs$
+            .pipe(switchMap(jobs => {
+            if (jobs.length) {
+                return interval(2500).pipe(mapTo(jobs));
+            }
+            else {
+                return of([]);
+            }
+        }))
+            .subscribe(jobs => {
+            if (jobs.length) {
+                this.dataService.settings.pollJobs(jobs.map(j => j.id)).single$.subscribe(data => {
+                    data.jobsById.forEach(job => {
+                        this.updateJob$.next(job);
+                    });
+                });
+            }
+        });
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    /**
+     * After a given delay, checks the server for any active jobs.
+     */
+    checkForJobs(delay = 1000) {
+        timer(delay)
+            .pipe(switchMap(() => this.dataService.client.userStatus().mapSingle(data => data.userStatus)), switchMap(userStatus => {
+            if (userStatus.permissions.includes(Permission.ReadSettings) && userStatus.isLoggedIn) {
+                return this.dataService.settings.getRunningJobs().single$;
+            }
+            else {
+                return EMPTY;
+            }
+        }))
+            .subscribe(data => data.jobs.items.forEach(job => this.updateJob$.next(job)));
+    }
+    addJob(jobId, onComplete) {
+        this.dataService.settings.getJob(jobId).single$.subscribe(({ job }) => {
+            if (job) {
+                this.updateJob$.next(job);
+                if (onComplete) {
+                    this.onCompleteHandlers.set(jobId, onComplete);
+                }
+            }
+        });
+    }
+    handleJob(jobMap, job) {
+        switch (job.state) {
+            case JobState.RUNNING:
+            case JobState.PENDING:
+                jobMap.set(job.id, job);
+                break;
+            case JobState.COMPLETED:
+            case JobState.FAILED:
+            case JobState.CANCELLED:
+                jobMap.delete(job.id);
+                const handler = this.onCompleteHandlers.get(job.id);
+                if (handler) {
+                    handler(job);
+                    this.onCompleteHandlers.delete(job.id);
+                }
+                break;
+        }
+        return jobMap;
+    }
+}
+JobQueueService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: JobQueueService, deps: [{ token: i1.DataService }], target: i0.ɵɵFactoryTarget.Injectable });
+JobQueueService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: JobQueueService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: JobQueueService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DataService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"job-queue.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/job-queue/job-queue.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { EMPTY, interval, Observable, of, Subject, Subscription, timer } from 'rxjs';\nimport { debounceTime, map, mapTo, scan, shareReplay, switchMap } from 'rxjs/operators';\n\nimport { JobInfoFragment, JobState, Permission } from '../../common/generated-types';\nimport { DataService } from '../../data/providers/data.service';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class JobQueueService implements OnDestroy {\n    activeJobs$: Observable<JobInfoFragment[]>;\n\n    private updateJob$ = new Subject<JobInfoFragment>();\n    private onCompleteHandlers = new Map<string, (job: JobInfoFragment) => void>();\n    private readonly subscription: Subscription;\n\n    constructor(private dataService: DataService) {\n        this.checkForJobs();\n\n        this.activeJobs$ = this.updateJob$.pipe(\n            scan<JobInfoFragment, Map<string, JobInfoFragment>>(\n                (jobMap, job) => this.handleJob(jobMap, job),\n                new Map<string, JobInfoFragment>(),\n            ),\n            map(jobMap => Array.from(jobMap.values())),\n            debounceTime(500),\n            shareReplay(1),\n        );\n\n        this.subscription = this.activeJobs$\n            .pipe(\n                switchMap(jobs => {\n                    if (jobs.length) {\n                        return interval(2500).pipe(mapTo(jobs));\n                    } else {\n                        return of([]);\n                    }\n                }),\n            )\n            .subscribe(jobs => {\n                if (jobs.length) {\n                    this.dataService.settings.pollJobs(jobs.map(j => j.id)).single$.subscribe(data => {\n                        data.jobsById.forEach(job => {\n                            this.updateJob$.next(job);\n                        });\n                    });\n                }\n            });\n    }\n\n    ngOnDestroy(): void {\n        if (this.subscription) {\n            this.subscription.unsubscribe();\n        }\n    }\n\n    /**\n     * After a given delay, checks the server for any active jobs.\n     */\n    checkForJobs(delay: number = 1000) {\n        timer(delay)\n            .pipe(\n                switchMap(() => this.dataService.client.userStatus().mapSingle(data => data.userStatus)),\n                switchMap(userStatus => {\n                    if (userStatus.permissions.includes(Permission.ReadSettings) && userStatus.isLoggedIn) {\n                        return this.dataService.settings.getRunningJobs().single$;\n                    } else {\n                        return EMPTY;\n                    }\n                }),\n            )\n            .subscribe(data => data.jobs.items.forEach(job => this.updateJob$.next(job)));\n    }\n\n    addJob(jobId: string, onComplete?: (job: JobInfoFragment) => void) {\n        this.dataService.settings.getJob(jobId).single$.subscribe(({ job }) => {\n            if (job) {\n                this.updateJob$.next(job);\n                if (onComplete) {\n                    this.onCompleteHandlers.set(jobId, onComplete);\n                }\n            }\n        });\n    }\n\n    private handleJob(jobMap: Map<string, JobInfoFragment>, job: JobInfoFragment) {\n        switch (job.state) {\n            case JobState.RUNNING:\n            case JobState.PENDING:\n                jobMap.set(job.id, job);\n                break;\n            case JobState.COMPLETED:\n            case JobState.FAILED:\n            case JobState.CANCELLED:\n                jobMap.delete(job.id);\n                const handler = this.onCompleteHandlers.get(job.id);\n                if (handler) {\n                    handler(job);\n                    this.onCompleteHandlers.delete(job.id);\n                }\n                break;\n        }\n        return jobMap;\n    }\n}\n"]}

package/esm2020/core/providers/local-storage/local-storage.service.mjs

@@ -0,0 +1,77 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+const PREFIX = 'vnd_';
+/**
+ * Wrapper around the browser's LocalStorage / SessionStorage object, for persisting data to the browser.
+ */
+export class LocalStorageService {
+    constructor(location) {
+        this.location = location;
+    }
+    /**
+     * Set a key-value pair in the browser's LocalStorage
+     */
+    set(key, value) {
+        const keyName = this.keyName(key);
+        localStorage.setItem(keyName, JSON.stringify(value));
+    }
+    /**
+     * Set a key-value pair specific to the current location (url)
+     */
+    setForCurrentLocation(key, value) {
+        const compositeKey = this.getLocationBasedKey(key);
+        this.set(compositeKey, value);
+    }
+    /**
+     * Set a key-value pair in the browser's SessionStorage
+     */
+    setForSession(key, value) {
+        const keyName = this.keyName(key);
+        sessionStorage.setItem(keyName, JSON.stringify(value));
+    }
+    /**
+     * Get the value of the given key from the SessionStorage or LocalStorage.
+     */
+    get(key) {
+        const keyName = this.keyName(key);
+        const item = sessionStorage.getItem(keyName) || localStorage.getItem(keyName);
+        let result;
+        try {
+            result = JSON.parse(item || 'null');
+        }
+        catch (e) {
+            // tslint:disable-next-line:no-console
+            console.error(`Could not parse the localStorage value for "${key}" (${item})`);
+        }
+        return result;
+    }
+    /**
+     * Get the value of the given key for the current location (url)
+     */
+    getForCurrentLocation(key) {
+        const compositeKey = this.getLocationBasedKey(key);
+        return this.get(compositeKey);
+    }
+    remove(key) {
+        const keyName = this.keyName(key);
+        sessionStorage.removeItem(keyName);
+        localStorage.removeItem(keyName);
+    }
+    getLocationBasedKey(key) {
+        const path = this.location.path();
+        return key + path;
+    }
+    keyName(key) {
+        return PREFIX + key;
+    }
+}
+LocalStorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocalStorageService, deps: [{ token: i1.Location }], target: i0.ɵɵFactoryTarget.Injectable });
+LocalStorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocalStorageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Location }]; } });
+//# sourceMappingURL=data:application/json;base64,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