@deenruv/admin-ui 1.0.0

package/esm2022/core/common/base-list.component.mjs

@@ -0,0 +1,186 @@
+import { DestroyRef, Directive, inject } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { BehaviorSubject, combineLatest, merge, Subject } from 'rxjs';
+import { debounceTime, distinctUntilChanged, filter, map, shareReplay, takeUntil, tap } from 'rxjs/operators';
+import { DataService } from '../data/providers/data.service';
+import { ServerConfigService } from '../data/server-config';
+import { DataTableFilterCollection } from '../providers/data-table/data-table-filter-collection';
+import { DataTableSortCollection } from '../providers/data-table/data-table-sort-collection';
+import { PermissionsService } from '../providers/permissions/permissions.service';
+import { SelectionManager } from './utilities/selection-manager';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+/**
+ * @description
+ * This is a base class which implements the logic required to fetch and manipulate
+ * a list of data from a query which returns a PaginatedList type.
+ *
+ * It is normally used in combination with the {@link DataTable2Component}.
+ *
+ * @docsCategory list-detail-views
+ */
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class BaseListComponent {
+    constructor(router, route) {
+        this.router = router;
+        this.route = route;
+        this.searchTermControl = new FormControl('');
+        this.selectionManager = new SelectionManager({
+            multiSelect: true,
+            itemsAreEqual: (a, b) => a.id === b.id,
+            additiveMode: true,
+        });
+        this.destroy$ = new Subject();
+        this.onPageChangeFn = (skip, take) => ({ options: { skip, take } });
+        this.refresh$ = new BehaviorSubject(undefined);
+        this.defaults = { take: 10, skip: 0 };
+    }
+    /**
+     * @description
+     * Sets the fetch function for the list being implemented.
+     */
+    setQueryFn(listQueryFn, mappingFn, onPageChangeFn, defaults) {
+        this.listQueryFn = listQueryFn;
+        this.mappingFn = mappingFn;
+        if (onPageChangeFn) {
+            this.onPageChangeFn = onPageChangeFn;
+        }
+        if (defaults) {
+            this.defaults = defaults;
+        }
+    }
+    /** @internal */
+    ngOnInit() {
+        if (!this.listQueryFn) {
+            throw new Error(`No listQueryFn has been defined. Please call super.setQueryFn() in the constructor.`);
+        }
+        this.listQuery = this.listQueryFn(this.defaults.take, this.defaults.skip);
+        const fetchPage = ([currentPage, itemsPerPage, _]) => {
+            const take = itemsPerPage;
+            const skip = (currentPage - 1) * itemsPerPage;
+            this.listQuery.ref.refetch(this.onPageChangeFn(skip, take));
+        };
+        this.result$ = this.listQuery.stream$.pipe(shareReplay(1));
+        this.items$ = this.result$.pipe(map(data => this.mappingFn(data).items));
+        this.totalItems$ = this.result$.pipe(map(data => this.mappingFn(data).totalItems));
+        this.currentPage$ = this.route.queryParamMap.pipe(map(qpm => qpm.get('page')), map(page => (!page ? 1 : +page)), distinctUntilChanged());
+        this.itemsPerPage$ = this.route.queryParamMap.pipe(map(qpm => qpm.get('perPage')), map(perPage => (!perPage ? this.defaults.take : +perPage)), distinctUntilChanged());
+        combineLatest(this.currentPage$, this.itemsPerPage$, this.refresh$)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(fetchPage);
+    }
+    /**
+     * @description
+     * Accepts a list of Observables which will trigger a refresh of the list when any of them emit.
+     */
+    refreshListOnChanges(...streams) {
+        const searchTerm$ = this.searchTermControl.valueChanges.pipe(filter(value => value !== null && (2 < value.length || value.length === 0)), debounceTime(250), tap(() => this.setPageNumber(1)));
+        merge(searchTerm$, ...streams)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(() => this.refresh$.next(undefined));
+    }
+    /** @internal */
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+        this.listQuery.completed$.next();
+    }
+    /**
+     * @description
+     * Sets the current page number in the url.
+     */
+    setPageNumber(page) {
+        this.setQueryParam('page', page, { replaceUrl: true });
+    }
+    /**
+     * @description
+     * Sets the number of items per page in the url.
+     */
+    setItemsPerPage(perPage) {
+        this.setQueryParam('perPage', perPage, { replaceUrl: true });
+    }
+    /**
+     * @description
+     * Re-fetch the current page of results.
+     */
+    refresh() {
+        this.refresh$.next(undefined);
+    }
+    setQueryParam(keyOrHash, valueOrOptions, maybeOptions) {
+        const options = (typeof keyOrHash === 'string' ? maybeOptions : valueOrOptions) ?? {};
+        this.router.navigate(['./'], {
+            queryParams: typeof keyOrHash === 'string' ? { [keyOrHash]: valueOrOptions } : keyOrHash,
+            relativeTo: this.route,
+            queryParamsHandling: 'merge',
+            ...options,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseListComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: BaseListComponent, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseListComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i1.ActivatedRoute }] });
+/**
+ * @description
+ * A version of the {@link BaseListComponent} which is designed to be used with a
+ * [TypedDocumentNode](https://the-guild.dev/graphql/codegen/plugins/typescript/typed-document-node).
+ *
+ * @docsCategory list-detail-views
+ */
+export class TypedBaseListComponent extends BaseListComponent {
+    constructor() {
+        super(inject(Router), inject(ActivatedRoute));
+        this.dataService = inject(DataService);
+        this.router = inject(Router);
+        this.serverConfigService = inject(ServerConfigService);
+        this.permissionsService = inject(PermissionsService);
+        this.refreshStreams = [];
+        this.collections = [];
+        const destroyRef = inject(DestroyRef);
+        destroyRef.onDestroy(() => {
+            this.collections.forEach(c => c.destroy());
+        });
+    }
+    configure(config) {
+        super.setQueryFn((args) => this.dataService.query(config.document).refetchOnChannelChange(), data => config.getItems(data), (skip, take) => config.setVariables?.(skip, take) ?? {});
+        this.availableLanguages$ = this.serverConfigService.getAvailableLanguages();
+        this.contentLanguage$ = this.dataService.client
+            .uiState()
+            .mapStream(({ uiState }) => uiState.contentLanguage)
+            .pipe(tap(() => this.refresh()));
+        this.refreshStreams = config.refreshListOnChanges ?? [];
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        super.refreshListOnChanges(this.contentLanguage$, ...this.refreshStreams);
+    }
+    createFilterCollection() {
+        const collection = new DataTableFilterCollection(this.router);
+        this.collections.push(collection);
+        return collection;
+    }
+    createSortCollection() {
+        const collection = new DataTableSortCollection(this.router);
+        this.collections.push(collection);
+        return collection;
+    }
+    setLanguage(code) {
+        this.dataService.client.setContentLanguage(code).subscribe();
+    }
+    getCustomFieldConfig(key) {
+        return this.serverConfigService.getCustomFieldsFor(key).filter(f => {
+            if (f.requiresPermission?.length) {
+                return this.permissionsService.userHasPermissions(f.requiresPermission);
+            }
+            return true;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TypedBaseListComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: TypedBaseListComponent, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TypedBaseListComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-list.component.js","sourceRoot":"","sources":["../../../../src/lib/core/src/common/base-list.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { DestroyRef, Directive, inject, OnDestroy, OnInit } from '@angular/core';\nimport { FormControl } from '@angular/forms';\nimport { ActivatedRoute, QueryParamsHandling, Router } from '@angular/router';\nimport { ResultOf, TypedDocumentNode, VariablesOf } from '@graphql-typed-document-node/core';\nimport { BehaviorSubject, combineLatest, merge, Observable, Subject } from 'rxjs';\nimport { debounceTime, distinctUntilChanged, filter, map, shareReplay, takeUntil, tap } from 'rxjs/operators';\nimport { DataService } from '../data/providers/data.service';\n\nimport { QueryResult } from '../data/query-result';\nimport { ServerConfigService } from '../data/server-config';\nimport { DataTableFilterCollection } from '../providers/data-table/data-table-filter-collection';\nimport { DataTableSortCollection } from '../providers/data-table/data-table-sort-collection';\nimport { PermissionsService } from '../providers/permissions/permissions.service';\nimport { CustomFieldConfig, CustomFields, LanguageCode } from './generated-types';\nimport { SelectionManager } from './utilities/selection-manager';\n\nexport type ListQueryFn<R> = (take: number, skip: number, ...args: any[]) => QueryResult<R, any>;\nexport type MappingFn<T, R> = (result: R) => { items: T[]; totalItems: number };\nexport type OnPageChangeFn<V> = (skip: number, take: number) => V;\n\n/**\n * Unwraps a query that returns a paginated list with an \"items\" property,\n * returning the type of one of the items in the array.\n */\nexport type ItemOf<T, K extends keyof T> = T[K] extends { items: infer R }\n    ? R extends any[]\n        ? R[number]\n        : R\n    : never;\n\n/**\n * @description\n * This is a base class which implements the logic required to fetch and manipulate\n * a list of data from a query which returns a PaginatedList type.\n *\n * It is normally used in combination with the {@link DataTable2Component}.\n *\n * @docsCategory list-detail-views\n */\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport class BaseListComponent<ResultType, ItemType, VariableType extends Record<string, any> = any>\n    implements OnInit, OnDestroy\n{\n    searchTermControl = new FormControl('');\n    selectionManager = new SelectionManager<any>({\n        multiSelect: true,\n        itemsAreEqual: (a, b) => a.id === b.id,\n        additiveMode: true,\n    });\n    result$: Observable<ResultType>;\n    items$: Observable<ItemType[]>;\n    totalItems$: Observable<number>;\n    itemsPerPage$: Observable<number>;\n    currentPage$: Observable<number>;\n    protected destroy$ = new Subject<void>();\n    private listQuery: QueryResult<ResultType, VariableType>;\n    private listQueryFn: ListQueryFn<ResultType>;\n    private mappingFn: MappingFn<ItemType, ResultType>;\n    private onPageChangeFn: OnPageChangeFn<VariableType> = (skip, take) =>\n        ({ options: { skip, take } } as any);\n    protected refresh$ = new BehaviorSubject<undefined>(undefined);\n    private defaults: { take: number; skip: number } = { take: 10, skip: 0 };\n\n    constructor(protected router: Router, protected route: ActivatedRoute) {}\n\n    /**\n     * @description\n     * Sets the fetch function for the list being implemented.\n     */\n    setQueryFn(\n        listQueryFn: ListQueryFn<ResultType>,\n        mappingFn: MappingFn<ItemType, ResultType>,\n        onPageChangeFn?: OnPageChangeFn<VariableType>,\n        defaults?: { take: number; skip: number },\n    ) {\n        this.listQueryFn = listQueryFn;\n        this.mappingFn = mappingFn;\n        if (onPageChangeFn) {\n            this.onPageChangeFn = onPageChangeFn;\n        }\n        if (defaults) {\n            this.defaults = defaults;\n        }\n    }\n\n    /** @internal */\n    ngOnInit() {\n        if (!this.listQueryFn) {\n            throw new Error(\n                `No listQueryFn has been defined. Please call super.setQueryFn() in the constructor.`,\n            );\n        }\n        this.listQuery = this.listQueryFn(this.defaults.take, this.defaults.skip);\n\n        const fetchPage = ([currentPage, itemsPerPage, _]: [number, number, undefined]) => {\n            const take = itemsPerPage;\n            const skip = (currentPage - 1) * itemsPerPage;\n            this.listQuery.ref.refetch(this.onPageChangeFn(skip, take));\n        };\n\n        this.result$ = this.listQuery.stream$.pipe(shareReplay(1));\n        this.items$ = this.result$.pipe(map(data => this.mappingFn(data).items));\n        this.totalItems$ = this.result$.pipe(map(data => this.mappingFn(data).totalItems));\n        this.currentPage$ = this.route.queryParamMap.pipe(\n            map(qpm => qpm.get('page')),\n            map(page => (!page ? 1 : +page)),\n            distinctUntilChanged(),\n        );\n        this.itemsPerPage$ = this.route.queryParamMap.pipe(\n            map(qpm => qpm.get('perPage')),\n            map(perPage => (!perPage ? this.defaults.take : +perPage)),\n            distinctUntilChanged(),\n        );\n\n        combineLatest(this.currentPage$, this.itemsPerPage$, this.refresh$)\n            .pipe(takeUntil(this.destroy$))\n            .subscribe(fetchPage);\n    }\n\n    /**\n     * @description\n     * Accepts a list of Observables which will trigger a refresh of the list when any of them emit.\n     */\n    protected refreshListOnChanges(...streams: Array<Observable<any>>) {\n        const searchTerm$ = this.searchTermControl.valueChanges.pipe(\n            filter(value => value !== null && (2 < value.length || value.length === 0)),\n            debounceTime(250),\n            tap(() => this.setPageNumber(1)),\n        );\n\n        merge(searchTerm$, ...streams)\n            .pipe(takeUntil(this.destroy$))\n            .subscribe(() => this.refresh$.next(undefined));\n    }\n\n    /** @internal */\n    ngOnDestroy() {\n        this.destroy$.next();\n        this.destroy$.complete();\n        this.listQuery.completed$.next();\n    }\n\n    /**\n     * @description\n     * Sets the current page number in the url.\n     */\n    setPageNumber(page: number) {\n        this.setQueryParam('page', page, { replaceUrl: true });\n    }\n\n    /**\n     * @description\n     * Sets the number of items per page in the url.\n     */\n    setItemsPerPage(perPage: number) {\n        this.setQueryParam('perPage', perPage, { replaceUrl: true });\n    }\n\n    /**\n     * @description\n     * Re-fetch the current page of results.\n     */\n    refresh() {\n        this.refresh$.next(undefined);\n    }\n\n    protected setQueryParam(\n        hash: { [key: string]: any },\n        options?: { replaceUrl?: boolean; queryParamsHandling?: QueryParamsHandling },\n    );\n    protected setQueryParam(\n        key: string,\n        value: any,\n        options?: { replaceUrl?: boolean; queryParamsHandling?: QueryParamsHandling },\n    );\n    protected setQueryParam(\n        keyOrHash: string | { [key: string]: any },\n        valueOrOptions?: any,\n        maybeOptions?: { replaceUrl?: boolean; queryParamsHandling?: QueryParamsHandling },\n    ) {\n        const options = (typeof keyOrHash === 'string' ? maybeOptions : valueOrOptions) ?? {};\n        this.router.navigate(['./'], {\n            queryParams: typeof keyOrHash === 'string' ? { [keyOrHash]: valueOrOptions } : keyOrHash,\n            relativeTo: this.route,\n            queryParamsHandling: 'merge',\n            ...options,\n        });\n    }\n}\n\n/**\n * @description\n * A version of the {@link BaseListComponent} which is designed to be used with a\n * [TypedDocumentNode](https://the-guild.dev/graphql/codegen/plugins/typescript/typed-document-node).\n *\n * @docsCategory list-detail-views\n */\n@Directive()\nexport class TypedBaseListComponent<\n        T extends TypedDocumentNode<any, Vars>,\n        Field extends keyof ResultOf<T>,\n        Vars extends { options: { filter: any; sort: any } } = VariablesOf<T>,\n    >\n    extends BaseListComponent<ResultOf<T>, ItemOf<ResultOf<T>, Field>, VariablesOf<T>>\n    implements OnInit\n{\n    availableLanguages$: Observable<LanguageCode[]>;\n    contentLanguage$: Observable<LanguageCode>;\n\n    protected dataService = inject(DataService);\n    protected router = inject(Router);\n    protected serverConfigService = inject(ServerConfigService);\n    protected permissionsService = inject(PermissionsService);\n    private refreshStreams: Array<Observable<any>> = [];\n    private collections: Array<DataTableFilterCollection | DataTableSortCollection<any>> = [];\n    constructor() {\n        super(inject(Router), inject(ActivatedRoute));\n\n        const destroyRef = inject(DestroyRef);\n        destroyRef.onDestroy(() => {\n            this.collections.forEach(c => c.destroy());\n        });\n    }\n\n    protected configure(config: {\n        document: T;\n        getItems: (data: ResultOf<T>) => { items: Array<ItemOf<ResultOf<T>, Field>>; totalItems: number };\n        setVariables?: (skip: number, take: number) => VariablesOf<T>;\n        refreshListOnChanges?: Array<Observable<any>>;\n    }) {\n        super.setQueryFn(\n            (args: any) => this.dataService.query(config.document).refetchOnChannelChange(),\n            data => config.getItems(data),\n            (skip, take) => config.setVariables?.(skip, take) ?? ({} as any),\n        );\n        this.availableLanguages$ = this.serverConfigService.getAvailableLanguages();\n        this.contentLanguage$ = this.dataService.client\n            .uiState()\n            .mapStream(({ uiState }) => uiState.contentLanguage)\n            .pipe(tap(() => this.refresh()));\n        this.refreshStreams = config.refreshListOnChanges ?? [];\n    }\n\n    ngOnInit() {\n        super.ngOnInit();\n        super.refreshListOnChanges(this.contentLanguage$, ...this.refreshStreams);\n    }\n\n    createFilterCollection(): DataTableFilterCollection<NonNullable<NonNullable<Vars['options']>['filter']>> {\n        const collection = new DataTableFilterCollection<NonNullable<Vars['options']['filter']>>(this.router);\n        this.collections.push(collection);\n        return collection;\n    }\n\n    createSortCollection(): DataTableSortCollection<NonNullable<NonNullable<Vars['options']>['sort']>> {\n        const collection = new DataTableSortCollection<NonNullable<Vars['options']['sort']>>(this.router);\n        this.collections.push(collection);\n        return collection;\n    }\n\n    setLanguage(code: LanguageCode) {\n        this.dataService.client.setContentLanguage(code).subscribe();\n    }\n\n    getCustomFieldConfig(key: Exclude<keyof CustomFields, '__typename'> | string): CustomFieldConfig[] {\n        return this.serverConfigService.getCustomFieldsFor(key).filter(f => {\n            if (f.requiresPermission?.length) {\n                return this.permissionsService.userHasPermissions(f.requiresPermission);\n            }\n            return true;\n        });\n    }\n}\n"]}

package/esm2022/core/common/component-registry-types.mjs

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

package/esm2022/core/common/deactivate-aware.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVhY3RpdmF0ZS1hd2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9zcmMvY29tbW9uL2RlYWN0aXZhdGUtYXdhcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVGhpcyBpbnRlcmZhY2Ugc2hvdWxkIGJlIGltcGxlbWVudGVkIGJ5IHRob3NlIHRvcC1sZXZlbCBjb21wb25lbnRzIHdoaWNoIHdhbnQgdG9cbiAqIHNpZ25hbCB0byB0aGUgdXNlciBpZiBhIHJvdXRlIGRlYWN0aXZhdGlvbiBpcyBhdHRlbXB0ZWQgaW4gYSBzdGF0ZSB3aGVyZSBjaGFnZXNcbiAqIHdvdWxkIGJlIGxvc3QuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRGVhY3RpdmF0ZUF3YXJlIHtcbiAgICBjYW5EZWFjdGl2YXRlKCk6IGJvb2xlYW47XG59XG4iXX0=

package/esm2022/core/common/detail-breadcrumb.mjs

@@ -0,0 +1,26 @@
+import { map } from 'rxjs/operators';
+/**
+ * Creates an observable of breadcrumb links for use in the route config of a detail route.
+ */
+export function detailBreadcrumb(options) {
+    return options.entity.pipe(map(entity => {
+        let label = '';
+        if (options.id === 'create') {
+            label = 'common.create';
+        }
+        else {
+            label = `${options.getName(entity)}`;
+        }
+        return [
+            {
+                label: options.breadcrumbKey,
+                link: ['../', options.route],
+            },
+            {
+                label,
+                link: [options.route, options.id],
+            },
+        ];
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,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