@vendure/admin-ui 1.7.4 → 1.8.0

package/package/esm2015/catalog/components/collection-tree/collection-tree.component.js

@@ -0,0 +1,77 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { arrayToTree } from './array-to-tree';
+export class CollectionTreeComponent {
+    constructor() {
+        this.expandAll = false;
+        this.expandedIds = [];
+        this.rearrange = new EventEmitter();
+        this.deleteCollection = new EventEmitter();
+        this.allMoveListItems = [];
+    }
+    ngOnChanges(changes) {
+        if ('collections' in changes && this.collections) {
+            this.collectionTree = arrayToTree(this.collections, this.collectionTree, this.expandedIds);
+            this.allMoveListItems = [];
+        }
+    }
+    onDrop(event) {
+        const item = event.item.data;
+        const newParent = event.container.data;
+        const newParentId = newParent.id;
+        if (newParentId == null) {
+            throw new Error(`Could not determine the ID of the root Collection`);
+        }
+        this.rearrange.emit({
+            collectionId: item.id,
+            parentId: newParentId,
+            index: event.currentIndex,
+        });
+    }
+    onMove(event) {
+        this.rearrange.emit(event);
+    }
+    onDelete(id) {
+        this.deleteCollection.emit(id);
+    }
+    getMoveListItems(collection) {
+        if (this.allMoveListItems.length === 0) {
+            this.allMoveListItems = this.calculateAllMoveListItems();
+        }
+        return this.allMoveListItems.filter(item => {
+            var _a;
+            return item.id !== collection.id &&
+                !item.ancestorIdPath.has(collection.id) &&
+                item.id !== ((_a = collection.parent) === null || _a === void 0 ? void 0 : _a.id);
+        });
+    }
+    calculateAllMoveListItems() {
+        const visit = (node, parentPath, ancestorIdPath, output) => {
+            const path = parentPath.concat(node.name);
+            output.push({ path: path.slice(1).join(' / ') || 'root', id: node.id, ancestorIdPath });
+            node.children.forEach(child => visit(child, path, new Set([...ancestorIdPath, node.id]), output));
+            return output;
+        };
+        return visit(this.collectionTree, [], new Set(), []);
+    }
+    isRootNode(node) {
+        return !node.hasOwnProperty('parent');
+    }
+}
+CollectionTreeComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-collection-tree',
+                template: "<vdr-collection-tree-node\r\n    *ngIf=\"collectionTree\"\r\n    cdkDropListGroup\r\n    [expandAll]=\"expandAll\"\r\n    [collectionTree]=\"collectionTree\"\r\n    [selectionManager]=\"selectionManager\"\r\n    [activeCollectionId]=\"activeCollectionId\"\r\n></vdr-collection-tree-node>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [""]
+            },] }
+];
+CollectionTreeComponent.propDecorators = {
+    collections: [{ type: Input }],
+    activeCollectionId: [{ type: Input }],
+    expandAll: [{ type: Input }],
+    expandedIds: [{ type: Input }],
+    selectionManager: [{ type: Input }],
+    rearrange: [{ type: Output }],
+    deleteCollection: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection-tree.component.js","sourceRoot":"","sources":["../../../../../src/lib/catalog/src/components/collection-tree/collection-tree.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkDragDrop } from '@angular/cdk/drag-drop';\r\nimport {\r\n    ChangeDetectionStrategy,\r\n    Component,\r\n    EventEmitter,\r\n    Input,\r\n    OnChanges,\r\n    Output,\r\n    SimpleChanges,\r\n} from '@angular/core';\r\nimport { Collection, SelectionManager } from '@vendure/admin-ui/core';\r\n\r\nimport { arrayToTree, HasParent, RootNode, TreeNode } from './array-to-tree';\r\n\r\nexport type RearrangeEvent = { collectionId: string; parentId: string; index: number };\r\nexport type CollectionPartial = Pick<Collection.Fragment, 'id' | 'parent' | 'name'>;\r\n\r\n@Component({\r\n    selector: 'vdr-collection-tree',\r\n    templateUrl: 'collection-tree.component.html',\r\n    styleUrls: ['./collection-tree.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class CollectionTreeComponent implements OnChanges {\r\n    @Input() collections: CollectionPartial[];\r\n    @Input() activeCollectionId: string;\r\n    @Input() expandAll = false;\r\n    @Input() expandedIds: string[] = [];\r\n    @Input() selectionManager: SelectionManager<CollectionPartial>;\r\n    @Output() rearrange = new EventEmitter<RearrangeEvent>();\r\n    @Output() deleteCollection = new EventEmitter<string>();\r\n    collectionTree: RootNode<CollectionPartial>;\r\n    private allMoveListItems: Array<{ path: string; id: string; ancestorIdPath: Set<string> }> = [];\r\n\r\n    ngOnChanges(changes: SimpleChanges) {\r\n        if ('collections' in changes && this.collections) {\r\n            this.collectionTree = arrayToTree(this.collections, this.collectionTree, this.expandedIds);\r\n            this.allMoveListItems = [];\r\n        }\r\n    }\r\n\r\n    onDrop(event: CdkDragDrop<CollectionPartial | RootNode<CollectionPartial>>) {\r\n        const item = event.item.data as CollectionPartial;\r\n        const newParent = event.container.data;\r\n        const newParentId = newParent.id;\r\n        if (newParentId == null) {\r\n            throw new Error(`Could not determine the ID of the root Collection`);\r\n        }\r\n        this.rearrange.emit({\r\n            collectionId: item.id,\r\n            parentId: newParentId,\r\n            index: event.currentIndex,\r\n        });\r\n    }\r\n\r\n    onMove(event: RearrangeEvent) {\r\n        this.rearrange.emit(event);\r\n    }\r\n\r\n    onDelete(id: string) {\r\n        this.deleteCollection.emit(id);\r\n    }\r\n\r\n    getMoveListItems(collection: CollectionPartial) {\r\n        if (this.allMoveListItems.length === 0) {\r\n            this.allMoveListItems = this.calculateAllMoveListItems();\r\n        }\r\n        return this.allMoveListItems.filter(\r\n            item =>\r\n                item.id !== collection.id &&\r\n                !item.ancestorIdPath.has(collection.id) &&\r\n                item.id !== collection.parent?.id,\r\n        );\r\n    }\r\n\r\n    calculateAllMoveListItems() {\r\n        const visit = (\r\n            node: TreeNode<any>,\r\n            parentPath: string[],\r\n            ancestorIdPath: Set<string>,\r\n            output: Array<{ path: string; id: string; ancestorIdPath: Set<string> }>,\r\n        ) => {\r\n            const path = parentPath.concat(node.name);\r\n            output.push({ path: path.slice(1).join(' / ') || 'root', id: node.id, ancestorIdPath });\r\n            node.children.forEach(child =>\r\n                visit(child, path, new Set<string>([...ancestorIdPath, node.id]), output),\r\n            );\r\n            return output;\r\n        };\r\n        return visit(this.collectionTree, [], new Set<string>(), []);\r\n    }\r\n\r\n    private isRootNode<T extends HasParent>(node: T | RootNode<T>): node is RootNode<T> {\r\n        return !node.hasOwnProperty('parent');\r\n    }\r\n}\r\n"]}

package/package/esm2015/catalog/components/facet-list/facet-list-bulk-actions.js

@@ -0,0 +1,208 @@
+import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
+import { currentChannelIsNotDefault, DataService, DeletionResult, getChannelCodeFromUserStatus, isMultiChannel, ModalService, NotificationService, Permission, } from '@vendure/admin-ui/core';
+import { unique } from '@vendure/common/lib/unique';
+import { EMPTY, of } from 'rxjs';
+import { map, mapTo, switchMap } from 'rxjs/operators';
+import { AssignToChannelDialogComponent } from '../assign-to-channel-dialog/assign-to-channel-dialog.component';
+const ɵ0 = userPermissions => userPermissions.includes(Permission.DeleteFacet) ||
+    userPermissions.includes(Permission.DeleteCatalog), ɵ1 = ({ injector, selection, hostComponent, clearSelection }) => {
+    const modalService = injector.get(ModalService);
+    const dataService = injector.get(DataService);
+    const notificationService = injector.get(NotificationService);
+    function showModalAndDelete(facetIds, message) {
+        return modalService
+            .dialog({
+            title: _('catalog.confirm-bulk-delete-facets'),
+            translationVars: {
+                count: selection.length,
+            },
+            size: message ? 'lg' : 'md',
+            body: message,
+            buttons: [
+                { type: 'secondary', label: _('common.cancel') },
+                {
+                    type: 'danger',
+                    label: message ? _('common.force-delete') : _('common.delete'),
+                    returnValue: true,
+                },
+            ],
+        })
+            .pipe(switchMap(res => res
+            ? dataService.facet
+                .deleteFacets(facetIds, !!message)
+                .pipe(map(res2 => res2.deleteFacets))
+            : of([])));
+    }
+    showModalAndDelete(unique(selection.map(f => f.id)))
+        .pipe(switchMap(result => {
+        var _a;
+        let deletedCount = 0;
+        const errors = [];
+        const errorIds = [];
+        let i = 0;
+        for (const item of result) {
+            if (item.result === DeletionResult.DELETED) {
+                deletedCount++;
+            }
+            else if (item.message) {
+                errors.push(item.message);
+                errorIds.push((_a = selection[i]) === null || _a === void 0 ? void 0 : _a.id);
+            }
+            i++;
+        }
+        if (0 < errorIds.length) {
+            return showModalAndDelete(errorIds, errors.join('\n')).pipe(map(result2 => {
+                const deletedCount2 = result2.filter(r => r.result === DeletionResult.DELETED).length;
+                return deletedCount + deletedCount2;
+            }));
+        }
+        else {
+            return of(deletedCount);
+        }
+    }))
+        .subscribe(deletedCount => {
+        if (deletedCount) {
+            hostComponent.refresh();
+            clearSelection();
+            notificationService.success(_('catalog.notify-bulk-delete-facets-success'), {
+                count: deletedCount,
+            });
+        }
+    });
+};
+export const deleteFacetsBulkAction = {
+    location: 'facet-list',
+    label: _('common.delete'),
+    icon: 'trash',
+    iconClass: 'is-danger',
+    requiresPermission: ɵ0,
+    onClick: ɵ1,
+};
+const ɵ2 = userPermissions => userPermissions.includes(Permission.UpdateFacet) ||
+    userPermissions.includes(Permission.UpdateCatalog), ɵ3 = ({ injector }) => isMultiChannel(injector.get(DataService)), ɵ4 = ({ injector, selection, hostComponent, clearSelection }) => {
+    const modalService = injector.get(ModalService);
+    const dataService = injector.get(DataService);
+    const notificationService = injector.get(NotificationService);
+    modalService
+        .fromComponent(AssignToChannelDialogComponent, {
+        size: 'md',
+        locals: {},
+    })
+        .pipe(switchMap(result => {
+        if (result) {
+            return dataService.facet
+                .assignFacetsToChannel({
+                facetIds: selection.map(f => f.id),
+                channelId: result.id,
+            })
+                .pipe(mapTo(result));
+        }
+        else {
+            return EMPTY;
+        }
+    }))
+        .subscribe(result => {
+        notificationService.success(_('catalog.assign-facets-to-channel-success'), {
+            count: selection.length,
+            channelCode: result.code,
+        });
+        clearSelection();
+    });
+};
+export const assignFacetsToChannelBulkAction = {
+    location: 'facet-list',
+    label: _('catalog.assign-to-channel'),
+    icon: 'layers',
+    requiresPermission: ɵ2,
+    isVisible: ɵ3,
+    onClick: ɵ4,
+};
+const ɵ5 = ({ injector }) => getChannelCodeFromUserStatus(injector.get(DataService)), ɵ6 = userPermissions => userPermissions.includes(Permission.UpdateFacet) ||
+    userPermissions.includes(Permission.UpdateCatalog), ɵ7 = ({ injector }) => currentChannelIsNotDefault(injector.get(DataService)), ɵ8 = ({ injector, selection, hostComponent, clearSelection }) => {
+    const modalService = injector.get(ModalService);
+    const dataService = injector.get(DataService);
+    const notificationService = injector.get(NotificationService);
+    const activeChannelId$ = dataService.client
+        .userStatus()
+        .mapSingle(({ userStatus }) => userStatus.activeChannelId);
+    function showModalAndDelete(facetIds, message) {
+        return modalService
+            .dialog({
+            title: _('catalog.remove-from-channel'),
+            translationVars: {
+                count: selection.length,
+            },
+            size: message ? 'lg' : 'md',
+            body: message,
+            buttons: [
+                { type: 'secondary', label: _('common.cancel') },
+                {
+                    type: 'danger',
+                    label: message ? _('common.force-remove') : _('common.remove'),
+                    returnValue: true,
+                },
+            ],
+        })
+            .pipe(switchMap(res => res
+            ? activeChannelId$.pipe(switchMap(activeChannelId => activeChannelId
+                ? dataService.facet.removeFacetsFromChannel({
+                    channelId: activeChannelId,
+                    facetIds,
+                    force: !!message,
+                })
+                : EMPTY), map(res2 => res2.removeFacetsFromChannel))
+            : EMPTY));
+    }
+    showModalAndDelete(unique(selection.map(f => f.id)))
+        .pipe(switchMap(result => {
+        var _a;
+        let removedCount = selection.length;
+        const errors = [];
+        const errorIds = [];
+        let i = 0;
+        for (const item of result) {
+            if (item.__typename === 'FacetInUseError') {
+                errors.push(item.message);
+                errorIds.push((_a = selection[i]) === null || _a === void 0 ? void 0 : _a.id);
+                removedCount--;
+            }
+            i++;
+        }
+        if (0 < errorIds.length) {
+            return showModalAndDelete(errorIds, errors.join('\n')).pipe(map(result2 => {
+                const notRemovedCount = result2.filter(r => r.__typename === 'FacetInUseError').length;
+                return selection.length - notRemovedCount;
+            }));
+        }
+        else {
+            return of(removedCount);
+        }
+    }), switchMap(removedCount => removedCount
+        ? getChannelCodeFromUserStatus(dataService).then(({ channelCode }) => ({
+            channelCode,
+            removedCount,
+        }))
+        : EMPTY))
+        .subscribe(({ removedCount, channelCode }) => {
+        if (removedCount) {
+            hostComponent.refresh();
+            clearSelection();
+            notificationService.success(_('catalog.notify-remove-facets-from-channel-success'), {
+                count: removedCount,
+                channelCode,
+            });
+        }
+    });
+};
+export const removeFacetsFromChannelBulkAction = {
+    location: 'facet-list',
+    label: _('catalog.remove-from-channel'),
+    getTranslationVars: ɵ5,
+    icon: 'layers',
+    iconClass: 'is-warning',
+    requiresPermission: ɵ6,
+    isVisible: ɵ7,
+    onClick: ɵ8,
+};
+export { ɵ0, ɵ1, ɵ2, ɵ3, ɵ4, ɵ5, ɵ6, ɵ7, ɵ8 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"facet-list-bulk-actions.js","sourceRoot":"","sources":["../../../../../src/lib/catalog/src/components/facet-list/facet-list-bulk-actions.ts"],"names":[],"mappings":"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","sourcesContent":["import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';\r\nimport {\r\n    BulkAction,\r\n    currentChannelIsNotDefault,\r\n    DataService,\r\n    DeletionResult,\r\n    getChannelCodeFromUserStatus,\r\n    GetFacetList,\r\n    isMultiChannel,\r\n    ModalService,\r\n    NotificationService,\r\n    Permission,\r\n} from '@vendure/admin-ui/core';\r\nimport { unique } from '@vendure/common/lib/unique';\r\nimport { EMPTY, of } from 'rxjs';\r\nimport { map, mapTo, switchMap } from 'rxjs/operators';\r\n\r\nimport { AssignToChannelDialogComponent } from '../assign-to-channel-dialog/assign-to-channel-dialog.component';\r\n\r\nimport { FacetListComponent } from './facet-list.component';\r\n\r\nexport const deleteFacetsBulkAction: BulkAction<GetFacetList.Items, FacetListComponent> = {\r\n    location: 'facet-list',\r\n    label: _('common.delete'),\r\n    icon: 'trash',\r\n    iconClass: 'is-danger',\r\n    requiresPermission: userPermissions =>\r\n        userPermissions.includes(Permission.DeleteFacet) ||\r\n        userPermissions.includes(Permission.DeleteCatalog),\r\n    onClick: ({ injector, selection, hostComponent, clearSelection }) => {\r\n        const modalService = injector.get(ModalService);\r\n        const dataService = injector.get(DataService);\r\n        const notificationService = injector.get(NotificationService);\r\n\r\n        function showModalAndDelete(facetIds: string[], message?: string) {\r\n            return modalService\r\n                .dialog({\r\n                    title: _('catalog.confirm-bulk-delete-facets'),\r\n                    translationVars: {\r\n                        count: selection.length,\r\n                    },\r\n                    size: message ? 'lg' : 'md',\r\n                    body: message,\r\n                    buttons: [\r\n                        { type: 'secondary', label: _('common.cancel') },\r\n                        {\r\n                            type: 'danger',\r\n                            label: message ? _('common.force-delete') : _('common.delete'),\r\n                            returnValue: true,\r\n                        },\r\n                    ],\r\n                })\r\n                .pipe(\r\n                    switchMap(res =>\r\n                        res\r\n                            ? dataService.facet\r\n                                  .deleteFacets(facetIds, !!message)\r\n                                  .pipe(map(res2 => res2.deleteFacets))\r\n                            : of([]),\r\n                    ),\r\n                );\r\n        }\r\n\r\n        showModalAndDelete(unique(selection.map(f => f.id)))\r\n            .pipe(\r\n                switchMap(result => {\r\n                    let deletedCount = 0;\r\n                    const errors: string[] = [];\r\n                    const errorIds: string[] = [];\r\n                    let i = 0;\r\n                    for (const item of result) {\r\n                        if (item.result === DeletionResult.DELETED) {\r\n                            deletedCount++;\r\n                        } else if (item.message) {\r\n                            errors.push(item.message);\r\n                            errorIds.push(selection[i]?.id);\r\n                        }\r\n                        i++;\r\n                    }\r\n                    if (0 < errorIds.length) {\r\n                        return showModalAndDelete(errorIds, errors.join('\\n')).pipe(\r\n                            map(result2 => {\r\n                                const deletedCount2 = result2.filter(\r\n                                    r => r.result === DeletionResult.DELETED,\r\n                                ).length;\r\n                                return deletedCount + deletedCount2;\r\n                            }),\r\n                        );\r\n                    } else {\r\n                        return of(deletedCount);\r\n                    }\r\n                }),\r\n            )\r\n            .subscribe(deletedCount => {\r\n                if (deletedCount) {\r\n                    hostComponent.refresh();\r\n                    clearSelection();\r\n                    notificationService.success(_('catalog.notify-bulk-delete-facets-success'), {\r\n                        count: deletedCount,\r\n                    });\r\n                }\r\n            });\r\n    },\r\n};\r\n\r\nexport const assignFacetsToChannelBulkAction: BulkAction<GetFacetList.Items, FacetListComponent> = {\r\n    location: 'facet-list',\r\n    label: _('catalog.assign-to-channel'),\r\n    icon: 'layers',\r\n    requiresPermission: userPermissions =>\r\n        userPermissions.includes(Permission.UpdateFacet) ||\r\n        userPermissions.includes(Permission.UpdateCatalog),\r\n    isVisible: ({ injector }) => isMultiChannel(injector.get(DataService)),\r\n    onClick: ({ injector, selection, hostComponent, clearSelection }) => {\r\n        const modalService = injector.get(ModalService);\r\n        const dataService = injector.get(DataService);\r\n        const notificationService = injector.get(NotificationService);\r\n        modalService\r\n            .fromComponent(AssignToChannelDialogComponent, {\r\n                size: 'md',\r\n                locals: {},\r\n            })\r\n            .pipe(\r\n                switchMap(result => {\r\n                    if (result) {\r\n                        return dataService.facet\r\n                            .assignFacetsToChannel({\r\n                                facetIds: selection.map(f => f.id),\r\n                                channelId: result.id,\r\n                            })\r\n                            .pipe(mapTo(result));\r\n                    } else {\r\n                        return EMPTY;\r\n                    }\r\n                }),\r\n            )\r\n            .subscribe(result => {\r\n                notificationService.success(_('catalog.assign-facets-to-channel-success'), {\r\n                    count: selection.length,\r\n                    channelCode: result.code,\r\n                });\r\n                clearSelection();\r\n            });\r\n    },\r\n};\r\n\r\nexport const removeFacetsFromChannelBulkAction: BulkAction<GetFacetList.Items, FacetListComponent> = {\r\n    location: 'facet-list',\r\n    label: _('catalog.remove-from-channel'),\r\n    getTranslationVars: ({ injector }) => getChannelCodeFromUserStatus(injector.get(DataService)),\r\n    icon: 'layers',\r\n    iconClass: 'is-warning',\r\n    requiresPermission: userPermissions =>\r\n        userPermissions.includes(Permission.UpdateFacet) ||\r\n        userPermissions.includes(Permission.UpdateCatalog),\r\n    isVisible: ({ injector }) => currentChannelIsNotDefault(injector.get(DataService)),\r\n    onClick: ({ injector, selection, hostComponent, clearSelection }) => {\r\n        const modalService = injector.get(ModalService);\r\n        const dataService = injector.get(DataService);\r\n        const notificationService = injector.get(NotificationService);\r\n\r\n        const activeChannelId$ = dataService.client\r\n            .userStatus()\r\n            .mapSingle(({ userStatus }) => userStatus.activeChannelId);\r\n\r\n        function showModalAndDelete(facetIds: string[], message?: string) {\r\n            return modalService\r\n                .dialog({\r\n                    title: _('catalog.remove-from-channel'),\r\n                    translationVars: {\r\n                        count: selection.length,\r\n                    },\r\n                    size: message ? 'lg' : 'md',\r\n                    body: message,\r\n                    buttons: [\r\n                        { type: 'secondary', label: _('common.cancel') },\r\n                        {\r\n                            type: 'danger',\r\n                            label: message ? _('common.force-remove') : _('common.remove'),\r\n                            returnValue: true,\r\n                        },\r\n                    ],\r\n                })\r\n                .pipe(\r\n                    switchMap(res =>\r\n                        res\r\n                            ? activeChannelId$.pipe(\r\n                                  switchMap(activeChannelId =>\r\n                                      activeChannelId\r\n                                          ? dataService.facet.removeFacetsFromChannel({\r\n                                                channelId: activeChannelId,\r\n                                                facetIds,\r\n                                                force: !!message,\r\n                                            })\r\n                                          : EMPTY,\r\n                                  ),\r\n                                  map(res2 => res2.removeFacetsFromChannel),\r\n                              )\r\n                            : EMPTY,\r\n                    ),\r\n                );\r\n        }\r\n\r\n        showModalAndDelete(unique(selection.map(f => f.id)))\r\n            .pipe(\r\n                switchMap(result => {\r\n                    let removedCount = selection.length;\r\n                    const errors: string[] = [];\r\n                    const errorIds: string[] = [];\r\n                    let i = 0;\r\n                    for (const item of result) {\r\n                        if (item.__typename === 'FacetInUseError') {\r\n                            errors.push(item.message);\r\n                            errorIds.push(selection[i]?.id);\r\n                            removedCount--;\r\n                        }\r\n                        i++;\r\n                    }\r\n                    if (0 < errorIds.length) {\r\n                        return showModalAndDelete(errorIds, errors.join('\\n')).pipe(\r\n                            map(result2 => {\r\n                                const notRemovedCount = result2.filter(\r\n                                    r => r.__typename === 'FacetInUseError',\r\n                                ).length;\r\n                                return selection.length - notRemovedCount;\r\n                            }),\r\n                        );\r\n                    } else {\r\n                        return of(removedCount);\r\n                    }\r\n                }),\r\n                switchMap(removedCount =>\r\n                    removedCount\r\n                        ? getChannelCodeFromUserStatus(dataService).then(({ channelCode }) => ({\r\n                              channelCode,\r\n                              removedCount,\r\n                          }))\r\n                        : EMPTY,\r\n                ),\r\n            )\r\n            .subscribe(({ removedCount, channelCode }) => {\r\n                if (removedCount) {\r\n                    hostComponent.refresh();\r\n                    clearSelection();\r\n                    notificationService.success(_('catalog.notify-remove-facets-from-channel-success'), {\r\n                        count: removedCount,\r\n                        channelCode,\r\n                    });\r\n                }\r\n            });\r\n    },\r\n};\r\n"]}

package/package/esm2015/catalog/components/facet-list/facet-list.component.js

@@ -0,0 +1,116 @@
+import { Component } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
+import { BaseListComponent, DataService, DeletionResult, ModalService, NotificationService, SelectionManager, ServerConfigService, } from '@vendure/admin-ui/core';
+import { SortOrder } from '@vendure/common/lib/generated-shop-types';
+import { EMPTY } from 'rxjs';
+import { debounceTime, filter, map, switchMap, takeUntil, tap } from 'rxjs/operators';
+export class FacetListComponent extends BaseListComponent {
+    constructor(dataService, modalService, notificationService, serverConfigService, router, route) {
+        super(router, route);
+        this.dataService = dataService;
+        this.modalService = modalService;
+        this.notificationService = notificationService;
+        this.serverConfigService = serverConfigService;
+        this.filterTermControl = new FormControl('');
+        this.initialLimit = 3;
+        this.displayLimit = {};
+        super.setQueryFn((...args) => this.dataService.facet.getFacets(...args).refetchOnChannelChange(), data => data.facets, (skip, take) => ({
+            options: {
+                skip,
+                take,
+                filter: {
+                    name: {
+                        contains: this.filterTermControl.value,
+                    },
+                },
+                sort: {
+                    createdAt: SortOrder.DESC,
+                },
+            },
+        }));
+        this.selectionManager = new SelectionManager({
+            multiSelect: true,
+            itemsAreEqual: (a, b) => a.id === b.id,
+            additiveMode: true,
+        });
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.availableLanguages$ = this.serverConfigService.getAvailableLanguages();
+        this.contentLanguage$ = this.dataService.client
+            .uiState()
+            .mapStream(({ uiState }) => uiState.contentLanguage)
+            .pipe(tap(() => this.refresh()));
+        this.filterTermControl.valueChanges
+            .pipe(filter(value => 2 <= value.length || value.length === 0), debounceTime(250), takeUntil(this.destroy$))
+            .subscribe(() => this.refresh());
+    }
+    toggleDisplayLimit(facet) {
+        if (this.displayLimit[facet.id] === facet.values.length) {
+            this.displayLimit[facet.id] = this.initialLimit;
+        }
+        else {
+            this.displayLimit[facet.id] = facet.values.length;
+        }
+    }
+    deleteFacet(facetValueId) {
+        this.showModalAndDelete(facetValueId)
+            .pipe(switchMap(response => {
+            if (response.result === DeletionResult.DELETED) {
+                return [true];
+            }
+            else {
+                return this.showModalAndDelete(facetValueId, response.message || '').pipe(map(r => r.result === DeletionResult.DELETED));
+            }
+        }), 
+        // Refresh the cached facets to reflect the changes
+        switchMap(() => this.dataService.facet.getAllFacets().single$))
+            .subscribe(() => {
+            this.notificationService.success(_('common.notify-delete-success'), {
+                entity: 'FacetValue',
+            });
+            this.refresh();
+        }, err => {
+            this.notificationService.error(_('common.notify-delete-error'), {
+                entity: 'FacetValue',
+            });
+        });
+    }
+    setLanguage(code) {
+        this.dataService.client.setContentLanguage(code).subscribe();
+    }
+    showModalAndDelete(facetId, message) {
+        return this.modalService
+            .dialog({
+            title: _('catalog.confirm-delete-facet'),
+            body: message,
+            buttons: [
+                { type: 'secondary', label: _('common.cancel') },
+                {
+                    type: 'danger',
+                    label: message ? _('common.force-delete') : _('common.delete'),
+                    returnValue: true,
+                },
+            ],
+        })
+            .pipe(switchMap(res => (res ? this.dataService.facet.deleteFacet(facetId, !!message) : EMPTY)), map(res => res.deleteFacet));
+    }
+}
+FacetListComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-facet-list',
+                template: "<vdr-action-bar>\n    <vdr-ab-left>\n        <div class=\"\">\n            <input\n                type=\"text\"\n                name=\"searchTerm\"\n                [formControl]=\"filterTermControl\"\n                [placeholder]=\"'catalog.filter-by-name' | translate\"\n                class=\"clr-input search-input\"\n            />\n            <div>\n                <vdr-language-selector\n                    [availableLanguageCodes]=\"availableLanguages$ | async\"\n                    [currentLanguageCode]=\"contentLanguage$ | async\"\n                    (languageCodeChange)=\"setLanguage($event)\"\n                ></vdr-language-selector>\n            </div>\n        </div>\n    </vdr-ab-left>\n    <vdr-ab-right>\n        <vdr-action-bar-items locationId=\"facet-list\"></vdr-action-bar-items>\n        <a\n            class=\"btn btn-primary\"\n            *vdrIfPermissions=\"['CreateCatalog', 'CreateFacet']\"\n            [routerLink]=\"['./create']\"\n        >\n            <clr-icon shape=\"plus\"></clr-icon>\n            {{ 'catalog.create-new-facet' | translate }}\n        </a>\n    </vdr-ab-right>\n</vdr-action-bar>\n\n<vdr-data-table\n    [items]=\"items$ | async\"\n    [itemsPerPage]=\"itemsPerPage$ | async\"\n    [totalItems]=\"totalItems$ | async\"\n    [currentPage]=\"currentPage$ | async\"\n    (pageChange)=\"setPageNumber($event)\"\n    (itemsPerPageChange)=\"setItemsPerPage($event)\"\n    [selectionManager]=\"selectionManager\"\n>\n    <vdr-bulk-action-menu\n        locationId=\"facet-list\"\n        [hostComponent]=\"this\"\n        [selectionManager]=\"selectionManager\"\n    ></vdr-bulk-action-menu>\n    <vdr-dt-column>{{ 'common.code' | translate }}</vdr-dt-column>\n    <vdr-dt-column>{{ 'common.name' | translate }}</vdr-dt-column>\n    <vdr-dt-column [expand]=\"true\">{{ 'catalog.values' | translate }}</vdr-dt-column>\n    <vdr-dt-column>{{ 'catalog.visibility' | translate }}</vdr-dt-column>\n    <vdr-dt-column></vdr-dt-column>\n    <vdr-dt-column></vdr-dt-column>\n    <ng-template let-facet=\"item\">\n        <td class=\"left align-middle\" [class.private]=\"facet.isPrivate\">{{ facet.code }}</td>\n        <td class=\"left align-middle\" [class.private]=\"facet.isPrivate\">{{ facet.name }}</td>\n        <td class=\"left align-middle\" [class.private]=\"facet.isPrivate\">\n            <vdr-facet-value-chip\n                *ngFor=\"let value of facet.values | slice: 0:displayLimit[facet.id] || 3\"\n                [facetValue]=\"value\"\n                [removable]=\"false\"\n                [displayFacetName]=\"false\"\n            ></vdr-facet-value-chip>\n            <button\n                class=\"btn btn-sm btn-secondary btn-icon\"\n                *ngIf=\"facet.values.length > initialLimit\"\n                (click)=\"toggleDisplayLimit(facet)\"\n            >\n                <ng-container *ngIf=\"(displayLimit[facet.id] || 0) < facet.values.length; else collapse\">\n                    <clr-icon shape=\"plus\"></clr-icon>\n                    {{ facet.values.length - initialLimit }}\n                </ng-container>\n                <ng-template #collapse>\n                    <clr-icon shape=\"minus\"></clr-icon>\n                </ng-template>\n            </button>\n        </td>\n        <td class=\"left align-middle\" [class.private]=\"facet.isPrivate\">\n            <vdr-chip>\n                <ng-container *ngIf=\"!facet.isPrivate; else private\">{{\n                    'catalog.public' | translate\n                }}</ng-container>\n                <ng-template #private>{{ 'catalog.private' | translate }}</ng-template>\n            </vdr-chip>\n        </td>\n        <td class=\"right align-middle\" [class.private]=\"facet.isPrivate\">\n            <vdr-table-row-action\n                iconShape=\"edit\"\n                [label]=\"'common.edit' | translate\"\n                [linkTo]=\"['./', facet.id]\"\n            ></vdr-table-row-action>\n        </td>\n        <td class=\"right align-middle\" [class.private]=\"facet.isPrivate\">\n            <vdr-dropdown>\n                <button type=\"button\" class=\"btn btn-link btn-sm\" vdrDropdownTrigger>\n                    {{ 'common.actions' | translate }}\n                    <clr-icon shape=\"caret down\"></clr-icon>\n                </button>\n                <vdr-dropdown-menu vdrPosition=\"bottom-right\">\n                    <button\n                        type=\"button\"\n                        class=\"delete-button\"\n                        (click)=\"deleteFacet(facet.id)\"\n                        [disabled]=\"!(['DeleteCatalog', 'DeleteFacet'] | hasPermission)\"\n                        vdrDropdownItem\n                    >\n                        <clr-icon shape=\"trash\" class=\"is-danger\"></clr-icon>\n                        {{ 'common.delete' | translate }}\n                    </button>\n                </vdr-dropdown-menu>\n            </vdr-dropdown>\n        </td>\n    </ng-template>\n</vdr-data-table>\n",
+                styles: ["td.private{background-color:var(--color-component-bg-200)}\n"]
+            },] }
+];
+FacetListComponent.ctorParameters = () => [
+    { type: DataService },
+    { type: ModalService },
+    { type: NotificationService },
+    { type: ServerConfigService },
+    { type: Router },
+    { type: ActivatedRoute }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"facet-list.component.js","sourceRoot":"","sources":["../../../../../src/lib/catalog/src/components/facet-list/facet-list.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit } from '@angular/core';\r\nimport { FormControl } from '@angular/forms';\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';\r\nimport {\r\n    BaseListComponent,\r\n    DataService,\r\n    DeletionResult,\r\n    GetFacetList,\r\n    LanguageCode,\r\n    ModalService,\r\n    NotificationService,\r\n    SelectionManager,\r\n    ServerConfigService,\r\n} from '@vendure/admin-ui/core';\r\nimport { SortOrder } from '@vendure/common/lib/generated-shop-types';\r\nimport { EMPTY, Observable } from 'rxjs';\r\nimport { debounceTime, filter, map, switchMap, takeUntil, tap } from 'rxjs/operators';\r\n\r\n@Component({\r\n    selector: 'vdr-facet-list',\r\n    templateUrl: './facet-list.component.html',\r\n    styleUrls: ['./facet-list.component.scss'],\r\n})\r\nexport class FacetListComponent\r\n    extends BaseListComponent<GetFacetList.Query, GetFacetList.Items>\r\n    implements OnInit\r\n{\r\n    filterTermControl = new FormControl('');\r\n    availableLanguages$: Observable<LanguageCode[]>;\r\n    contentLanguage$: Observable<LanguageCode>;\r\n    readonly initialLimit = 3;\r\n    displayLimit: { [id: string]: number } = {};\r\n    selectionManager: SelectionManager<GetFacetList.Items>;\r\n\r\n    constructor(\r\n        private dataService: DataService,\r\n        private modalService: ModalService,\r\n        private notificationService: NotificationService,\r\n        private serverConfigService: ServerConfigService,\r\n        router: Router,\r\n        route: ActivatedRoute,\r\n    ) {\r\n        super(router, route);\r\n        super.setQueryFn(\r\n            (...args: any[]) => this.dataService.facet.getFacets(...args).refetchOnChannelChange(),\r\n            data => data.facets,\r\n            (skip, take) => ({\r\n                options: {\r\n                    skip,\r\n                    take,\r\n                    filter: {\r\n                        name: {\r\n                            contains: this.filterTermControl.value,\r\n                        },\r\n                    },\r\n                    sort: {\r\n                        createdAt: SortOrder.DESC,\r\n                    },\r\n                },\r\n            }),\r\n        );\r\n        this.selectionManager = new SelectionManager<GetFacetList.Items>({\r\n            multiSelect: true,\r\n            itemsAreEqual: (a, b) => a.id === b.id,\r\n            additiveMode: true,\r\n        });\r\n    }\r\n\r\n    ngOnInit() {\r\n        super.ngOnInit();\r\n        this.availableLanguages$ = this.serverConfigService.getAvailableLanguages();\r\n        this.contentLanguage$ = this.dataService.client\r\n            .uiState()\r\n            .mapStream(({ uiState }) => uiState.contentLanguage)\r\n            .pipe(tap(() => this.refresh()));\r\n        this.filterTermControl.valueChanges\r\n            .pipe(\r\n                filter(value => 2 <= value.length || value.length === 0),\r\n                debounceTime(250),\r\n                takeUntil(this.destroy$),\r\n            )\r\n            .subscribe(() => this.refresh());\r\n    }\r\n\r\n    toggleDisplayLimit(facet: GetFacetList.Items) {\r\n        if (this.displayLimit[facet.id] === facet.values.length) {\r\n            this.displayLimit[facet.id] = this.initialLimit;\r\n        } else {\r\n            this.displayLimit[facet.id] = facet.values.length;\r\n        }\r\n    }\r\n\r\n    deleteFacet(facetValueId: string) {\r\n        this.showModalAndDelete(facetValueId)\r\n            .pipe(\r\n                switchMap(response => {\r\n                    if (response.result === DeletionResult.DELETED) {\r\n                        return [true];\r\n                    } else {\r\n                        return this.showModalAndDelete(facetValueId, response.message || '').pipe(\r\n                            map(r => r.result === DeletionResult.DELETED),\r\n                        );\r\n                    }\r\n                }),\r\n                // Refresh the cached facets to reflect the changes\r\n                switchMap(() => this.dataService.facet.getAllFacets().single$),\r\n            )\r\n            .subscribe(\r\n                () => {\r\n                    this.notificationService.success(_('common.notify-delete-success'), {\r\n                        entity: 'FacetValue',\r\n                    });\r\n                    this.refresh();\r\n                },\r\n                err => {\r\n                    this.notificationService.error(_('common.notify-delete-error'), {\r\n                        entity: 'FacetValue',\r\n                    });\r\n                },\r\n            );\r\n    }\r\n\r\n    setLanguage(code: LanguageCode) {\r\n        this.dataService.client.setContentLanguage(code).subscribe();\r\n    }\r\n\r\n    private showModalAndDelete(facetId: string, message?: string) {\r\n        return this.modalService\r\n            .dialog({\r\n                title: _('catalog.confirm-delete-facet'),\r\n                body: message,\r\n                buttons: [\r\n                    { type: 'secondary', label: _('common.cancel') },\r\n                    {\r\n                        type: 'danger',\r\n                        label: message ? _('common.force-delete') : _('common.delete'),\r\n                        returnValue: true,\r\n                    },\r\n                ],\r\n            })\r\n            .pipe(\r\n                switchMap(res => (res ? this.dataService.facet.deleteFacet(facetId, !!message) : EMPTY)),\r\n                map(res => res.deleteFacet),\r\n            );\r\n    }\r\n}\r\n"]}