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

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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

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

@@ -0,0 +1,97 @@
+import { Injectable } from '@angular/core';
+import { from, Observable } from 'rxjs';
+import { mergeMap } from 'rxjs/operators';
+import { ModalDialogComponent } from '../../shared/components/modal-dialog/modal-dialog.component';
+import { SimpleDialogComponent } from '../../shared/components/simple-dialog/simple-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../overlay-host/overlay-host.service";
+/**
+ * @description
+ * This service is responsible for instantiating a ModalDialog component and
+ * embedding the specified component within.
+ *
+ * @docsCategory providers
+ * @docsPage ModalService
+ * @docsWeight 0
+ */
+export class ModalService {
+    constructor(componentFactoryResolver, overlayHostService) {
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.overlayHostService = overlayHostService;
+    }
+    /**
+     * @description
+     * Create a modal from a component. The component must implement the {@link Dialog} interface.
+     * Additionally, the component should include templates for the title and the buttons to be
+     * displayed in the modal dialog. See example:
+     *
+     * @example
+     * ```HTML
+     * class MyDialog implements Dialog {
+     *  resolveWith: (result?: any) => void;
+     *
+     *  okay() {
+     *    doSomeWork().subscribe(result => {
+     *      this.resolveWith(result);
+     *    })
+     *  }
+     *
+     *  cancel() {
+     *    this.resolveWith(false);
+     *  }
+     * }
+     * ```
+     *
+     * @example
+     * ```HTML
+     * <ng-template vdrDialogTitle>Title of the modal</ng-template>
+     *
+     * <p>
+     *   My Content
+     * </p>
+     *
+     * <ng-template vdrDialogButtons>
+     *   <button type="button"
+     *           class="btn"
+     *           (click)="cancel()">Cancel</button>
+     *   <button type="button"
+     *           class="btn btn-primary"
+     *           (click)="okay()">Okay</button>
+     * </ng-template>
+     * ```
+     */
+    fromComponent(component, options) {
+        const modalFactory = this.componentFactoryResolver.resolveComponentFactory(ModalDialogComponent);
+        return from(this.overlayHostService.getHostView()).pipe(mergeMap(hostView => {
+            const modalComponentRef = hostView.createComponent(modalFactory);
+            const modalInstance = modalComponentRef.instance;
+            modalInstance.childComponentType = component;
+            modalInstance.options = options;
+            return new Observable(subscriber => {
+                modalInstance.closeModal = (result) => {
+                    modalComponentRef.destroy();
+                    subscriber.next(result);
+                    subscriber.complete();
+                };
+            });
+        }));
+    }
+    /**
+     * @description
+     * Displays a modal dialog with the provided title, body and buttons.
+     */
+    dialog(config) {
+        return this.fromComponent(SimpleDialogComponent, {
+            locals: config,
+        });
+    }
+}
+ModalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ModalService, deps: [{ token: i0.ComponentFactoryResolver }, { token: i1.OverlayHostService }], target: i0.ɵɵFactoryTarget.Injectable });
+ModalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ModalService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ModalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }, { type: i1.OverlayHostService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/providers/modal/modal.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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