@vendure/admin-ui 1.7.3 → 1.8.0

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

@@ -0,0 +1,147 @@
+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, from, of } from 'rxjs';
+import { mapTo, switchMap } from 'rxjs/operators';
+import { AssignToChannelDialogComponent } from '../assign-to-channel-dialog/assign-to-channel-dialog.component';
+const ɵ0 = userPermissions => userPermissions.includes(Permission.DeleteCollection) ||
+    userPermissions.includes(Permission.DeleteCatalog), ɵ1 = ({ injector, selection, hostComponent, clearSelection }) => {
+    const modalService = injector.get(ModalService);
+    const dataService = injector.get(DataService);
+    const notificationService = injector.get(NotificationService);
+    modalService
+        .dialog({
+        title: _('catalog.confirm-bulk-delete-collections'),
+        translationVars: {
+            count: selection.length,
+        },
+        buttons: [
+            { type: 'secondary', label: _('common.cancel') },
+            { type: 'danger', label: _('common.delete'), returnValue: true },
+        ],
+    })
+        .pipe(switchMap(response => response
+        ? dataService.collection.deleteCollections(unique(selection.map(c => c.id)))
+        : EMPTY))
+        .subscribe(result => {
+        let deleted = 0;
+        const errors = [];
+        for (const item of result.deleteCollections) {
+            if (item.result === DeletionResult.DELETED) {
+                deleted++;
+            }
+            else if (item.message) {
+                errors.push(item.message);
+            }
+        }
+        if (0 < deleted) {
+            notificationService.success(_('catalog.notify-bulk-delete-collections-success'), {
+                count: deleted,
+            });
+        }
+        if (0 < errors.length) {
+            notificationService.error(errors.join('\n'));
+        }
+        hostComponent.refresh();
+        clearSelection();
+    });
+};
+export const deleteCollectionsBulkAction = {
+    location: 'collection-list',
+    label: _('common.delete'),
+    icon: 'trash',
+    iconClass: 'is-danger',
+    requiresPermission: ɵ0,
+    onClick: ɵ1,
+};
+const ɵ2 = userPermissions => userPermissions.includes(Permission.UpdateCatalog) ||
+    userPermissions.includes(Permission.UpdateProduct), ɵ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.collection
+                .assignCollectionsToChannel({
+                collectionIds: selection.map(c => c.id),
+                channelId: result.id,
+            })
+                .pipe(mapTo(result));
+        }
+        else {
+            return EMPTY;
+        }
+    }))
+        .subscribe(result => {
+        notificationService.success(_('catalog.assign-collections-to-channel-success'), {
+            count: selection.length,
+            channelCode: result.code,
+        });
+        clearSelection();
+    });
+};
+export const assignCollectionsToChannelBulkAction = {
+    location: 'collection-list',
+    label: _('catalog.assign-to-channel'),
+    icon: 'layers',
+    requiresPermission: ɵ2,
+    isVisible: ɵ3,
+    onClick: ɵ4,
+};
+const ɵ5 = userPermissions => userPermissions.includes(Permission.UpdateChannel) ||
+    userPermissions.includes(Permission.UpdateProduct), ɵ6 = ({ injector }) => getChannelCodeFromUserStatus(injector.get(DataService)), ɵ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);
+    from(getChannelCodeFromUserStatus(injector.get(DataService)))
+        .pipe(switchMap(({ channelCode }) => modalService.dialog({
+        title: _('catalog.remove-from-channel'),
+        translationVars: {
+            channelCode,
+        },
+        buttons: [
+            { type: 'secondary', label: _('common.cancel') },
+            {
+                type: 'danger',
+                label: _('common.remove'),
+                returnValue: true,
+            },
+        ],
+    })), switchMap(res => res
+        ? activeChannelId$.pipe(switchMap(activeChannelId => activeChannelId
+            ? dataService.collection.removeCollectionsFromChannel({
+                channelId: activeChannelId,
+                collectionIds: selection.map(c => c.id),
+            })
+            : EMPTY), mapTo(true))
+        : of(false)))
+        .subscribe(removed => {
+        if (removed) {
+            clearSelection();
+            notificationService.success(_('catalog.notify-remove-collections-from-channel-success'), {
+                count: selection.length,
+            });
+            hostComponent.refresh();
+        }
+    });
+};
+export const removeCollectionsFromChannelBulkAction = {
+    location: 'collection-list',
+    label: _('catalog.remove-from-channel'),
+    requiresPermission: ɵ5,
+    getTranslationVars: ɵ6,
+    icon: 'layers',
+    iconClass: 'is-warning',
+    isVisible: ɵ7,
+    onClick: ɵ8,
+};
+export { ɵ0, ɵ1, ɵ2, ɵ3, ɵ4, ɵ5, ɵ6, ɵ7, ɵ8 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection-list-bulk-actions.js","sourceRoot":"","sources":["../../../../../src/lib/catalog/src/components/collection-list/collection-list-bulk-actions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,EAEH,0BAA0B,EAC1B,WAAW,EACX,cAAc,EACd,4BAA4B,EAC5B,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,UAAU,GACb,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,8BAA8B,EAAE,MAAM,gEAAgE,CAAC;WAUxF,eAAe,CAAC,EAAE,CAClC,eAAe,CAAC,QAAQ,CAAC,UAAU,CAAC,gBAAgB,CAAC;IACrD,eAAe,CAAC,QAAQ,CAAC,UAAU,CAAC,aAAa,CAAC,OAC7C,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,EAAE,EAAE;IAChE,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAChD,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC9C,MAAM,mBAAmB,GAAG,QAAQ,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;IAE9D,YAAY;SACP,MAAM,CAAC;QACJ,KAAK,EAAE,CAAC,CAAC,yCAAyC,CAAC;QACnD,eAAe,EAAE;YACb,KAAK,EAAE,SAAS,CAAC,MAAM;SAC1B;QACD,OAAO,EAAE;YACL,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC,EAAE;YAChD,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE;SACnE;KACJ,CAAC;SACD,IAAI,CACD,SAAS,CAAC,QAAQ,CAAC,EAAE,CACjB,QAAQ;QACJ,CAAC,CAAC,WAAW,CAAC,UAAU,CAAC,iBAAiB,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC5E,CAAC,CAAC,KAAK,CACd,CACJ;SACA,SAAS,CAAC,MAAM,CAAC,EAAE;QAChB,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,iBAAiB,EAAE;YACzC,IAAI,IAAI,CAAC,MAAM,KAAK,cAAc,CAAC,OAAO,EAAE;gBACxC,OAAO,EAAE,CAAC;aACb;iBAAM,IAAI,IAAI,CAAC,OAAO,EAAE;gBACrB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aAC7B;SACJ;QACD,IAAI,CAAC,GAAG,OAAO,EAAE;YACb,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,gDAAgD,CAAC,EAAE;gBAC7E,KAAK,EAAE,OAAO;aACjB,CAAC,CAAC;SACN;QACD,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE;YACnB,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;SAChD;QACD,aAAa,CAAC,OAAO,EAAE,CAAC;QACxB,cAAc,EAAE,CAAC;IACrB,CAAC,CAAC,CAAC;AACX,CAAC;AApDL,MAAM,CAAC,MAAM,2BAA2B,GAA2D;IAC/F,QAAQ,EAAE,iBAAiB;IAC3B,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC;IACzB,IAAI,EAAE,OAAO;IACb,SAAS,EAAE,WAAW;IACtB,kBAAkB,IAEoC;IACtD,OAAO,IA4CN;CACJ,CAAC;WAMsB,eAAe,CAAC,EAAE,CAClC,eAAe,CAAC,QAAQ,CAAC,UAAU,CAAC,aAAa,CAAC;IAClD,eAAe,CAAC,QAAQ,CAAC,UAAU,CAAC,aAAa,CAAC,OAC3C,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,OAC7D,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,EAAE,EAAE;IAChE,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAChD,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC9C,MAAM,mBAAmB,GAAG,QAAQ,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;IAC9D,YAAY;SACP,aAAa,CAAC,8BAA8B,EAAE;QAC3C,IAAI,EAAE,IAAI;QACV,MAAM,EAAE,EAAE;KACb,CAAC;SACD,IAAI,CACD,SAAS,CAAC,MAAM,CAAC,EAAE;QACf,IAAI,MAAM,EAAE;YACR,OAAO,WAAW,CAAC,UAAU;iBACxB,0BAA0B,CAAC;gBACxB,aAAa,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACvC,SAAS,EAAE,MAAM,CAAC,EAAE;aACvB,CAAC;iBACD,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;SAC5B;aAAM;YACH,OAAO,KAAK,CAAC;SAChB;IACL,CAAC,CAAC,CACL;SACA,SAAS,CAAC,MAAM,CAAC,EAAE;QAChB,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,+CAA+C,CAAC,EAAE;YAC5E,KAAK,EAAE,SAAS,CAAC,MAAM;YACvB,WAAW,EAAE,MAAM,CAAC,IAAI;SAC3B,CAAC,CAAC;QACH,cAAc,EAAE,CAAC;IACrB,CAAC,CAAC,CAAC;AACX,CAAC;AAtCL,MAAM,CAAC,MAAM,oCAAoC,GAA2D;IACxG,QAAQ,EAAE,iBAAiB;IAC3B,KAAK,EAAE,CAAC,CAAC,2BAA2B,CAAC;IACrC,IAAI,EAAE,QAAQ;IACd,kBAAkB,IAEoC;IACtD,SAAS,IAA6D;IACtE,OAAO,IA8BN;CACJ,CAAC;WAM0B,eAAe,CAAC,EAAE,CAClC,eAAe,CAAC,QAAQ,CAAC,UAAU,CAAC,aAAa,CAAC;IAClD,eAAe,CAAC,QAAQ,CAAC,UAAU,CAAC,aAAa,CAAC,OAClC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,4BAA4B,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,OAGlF,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,0BAA0B,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,OACzE,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,EAAE,EAAE;IAChE,MAAM,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAChD,MAAM,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC9C,MAAM,mBAAmB,GAAG,QAAQ,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;IAC9D,MAAM,gBAAgB,GAAG,WAAW,CAAC,MAAM;SACtC,UAAU,EAAE;SACZ,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;IAE/D,IAAI,CAAC,4BAA4B,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;SACxD,IAAI,CACD,SAAS,CAAC,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAC1B,YAAY,CAAC,MAAM,CAAC;QAChB,KAAK,EAAE,CAAC,CAAC,6BAA6B,CAAC;QACvC,eAAe,EAAE;YACb,WAAW;SACd;QACD,OAAO,EAAE;YACL,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC,EAAE;YAChD;gBACI,IAAI,EAAE,QAAQ;gBACd,KAAK,EAAE,CAAC,CAAC,eAAe,CAAC;gBACzB,WAAW,EAAE,IAAI;aACpB;SACJ;KACJ,CAAC,CACL,EACD,SAAS,CAAC,GAAG,CAAC,EAAE,CACZ,GAAG;QACC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CACjB,SAAS,CAAC,eAAe,CAAC,EAAE,CACxB,eAAe;YACX,CAAC,CAAC,WAAW,CAAC,UAAU,CAAC,4BAA4B,CAAC;gBAChD,SAAS,EAAE,eAAe;gBAC1B,aAAa,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAC1C,CAAC;YACJ,CAAC,CAAC,KAAK,CACd,EACD,KAAK,CAAC,IAAI,CAAC,CACd;QACH,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAClB,CACJ;SACA,SAAS,CAAC,OAAO,CAAC,EAAE;QACjB,IAAI,OAAO,EAAE;YACT,cAAc,EAAE,CAAC;YACjB,mBAAmB,CAAC,OAAO,CACvB,CAAC,CAAC,wDAAwD,CAAC,EAC3D;gBACI,KAAK,EAAE,SAAS,CAAC,MAAM;aAC1B,CACJ,CAAC;YACF,aAAa,CAAC,OAAO,EAAE,CAAC;SAC3B;IACL,CAAC,CAAC,CAAC;AACX,CAAC;AAjET,MAAM,CAAC,MAAM,sCAAsC,GAC/C;IACI,QAAQ,EAAE,iBAAiB;IAC3B,KAAK,EAAE,CAAC,CAAC,6BAA6B,CAAC;IACvC,kBAAkB,IAEoC;IACtD,kBAAkB,IAA2E;IAC7F,IAAI,EAAE,QAAQ;IACd,SAAS,EAAE,YAAY;IACvB,SAAS,IAAyE;IAClF,OAAO,IAsDN;CACJ,CAAC","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    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, from, of } from 'rxjs';\r\nimport { mapTo, switchMap } from 'rxjs/operators';\r\n\r\nimport { AssignToChannelDialogComponent } from '../assign-to-channel-dialog/assign-to-channel-dialog.component';\r\nimport { CollectionPartial } from '../collection-tree/collection-tree.component';\r\n\r\nimport { CollectionListComponent } from './collection-list.component';\r\n\r\nexport const deleteCollectionsBulkAction: BulkAction<CollectionPartial, CollectionListComponent> = {\r\n    location: 'collection-list',\r\n    label: _('common.delete'),\r\n    icon: 'trash',\r\n    iconClass: 'is-danger',\r\n    requiresPermission: userPermissions =>\r\n        userPermissions.includes(Permission.DeleteCollection) ||\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        modalService\r\n            .dialog({\r\n                title: _('catalog.confirm-bulk-delete-collections'),\r\n                translationVars: {\r\n                    count: selection.length,\r\n                },\r\n                buttons: [\r\n                    { type: 'secondary', label: _('common.cancel') },\r\n                    { type: 'danger', label: _('common.delete'), returnValue: true },\r\n                ],\r\n            })\r\n            .pipe(\r\n                switchMap(response =>\r\n                    response\r\n                        ? dataService.collection.deleteCollections(unique(selection.map(c => c.id)))\r\n                        : EMPTY,\r\n                ),\r\n            )\r\n            .subscribe(result => {\r\n                let deleted = 0;\r\n                const errors: string[] = [];\r\n                for (const item of result.deleteCollections) {\r\n                    if (item.result === DeletionResult.DELETED) {\r\n                        deleted++;\r\n                    } else if (item.message) {\r\n                        errors.push(item.message);\r\n                    }\r\n                }\r\n                if (0 < deleted) {\r\n                    notificationService.success(_('catalog.notify-bulk-delete-collections-success'), {\r\n                        count: deleted,\r\n                    });\r\n                }\r\n                if (0 < errors.length) {\r\n                    notificationService.error(errors.join('\\n'));\r\n                }\r\n                hostComponent.refresh();\r\n                clearSelection();\r\n            });\r\n    },\r\n};\r\n\r\nexport const assignCollectionsToChannelBulkAction: BulkAction<CollectionPartial, CollectionListComponent> = {\r\n    location: 'collection-list',\r\n    label: _('catalog.assign-to-channel'),\r\n    icon: 'layers',\r\n    requiresPermission: userPermissions =>\r\n        userPermissions.includes(Permission.UpdateCatalog) ||\r\n        userPermissions.includes(Permission.UpdateProduct),\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.collection\r\n                            .assignCollectionsToChannel({\r\n                                collectionIds: selection.map(c => c.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-collections-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 removeCollectionsFromChannelBulkAction: BulkAction<CollectionPartial, CollectionListComponent> =\r\n    {\r\n        location: 'collection-list',\r\n        label: _('catalog.remove-from-channel'),\r\n        requiresPermission: userPermissions =>\r\n            userPermissions.includes(Permission.UpdateChannel) ||\r\n            userPermissions.includes(Permission.UpdateProduct),\r\n        getTranslationVars: ({ injector }) => getChannelCodeFromUserStatus(injector.get(DataService)),\r\n        icon: 'layers',\r\n        iconClass: 'is-warning',\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            const activeChannelId$ = dataService.client\r\n                .userStatus()\r\n                .mapSingle(({ userStatus }) => userStatus.activeChannelId);\r\n\r\n            from(getChannelCodeFromUserStatus(injector.get(DataService)))\r\n                .pipe(\r\n                    switchMap(({ channelCode }) =>\r\n                        modalService.dialog({\r\n                            title: _('catalog.remove-from-channel'),\r\n                            translationVars: {\r\n                                channelCode,\r\n                            },\r\n                            buttons: [\r\n                                { type: 'secondary', label: _('common.cancel') },\r\n                                {\r\n                                    type: 'danger',\r\n                                    label: _('common.remove'),\r\n                                    returnValue: true,\r\n                                },\r\n                            ],\r\n                        }),\r\n                    ),\r\n                    switchMap(res =>\r\n                        res\r\n                            ? activeChannelId$.pipe(\r\n                                  switchMap(activeChannelId =>\r\n                                      activeChannelId\r\n                                          ? dataService.collection.removeCollectionsFromChannel({\r\n                                                channelId: activeChannelId,\r\n                                                collectionIds: selection.map(c => c.id),\r\n                                            })\r\n                                          : EMPTY,\r\n                                  ),\r\n                                  mapTo(true),\r\n                              )\r\n                            : of(false),\r\n                    ),\r\n                )\r\n                .subscribe(removed => {\r\n                    if (removed) {\r\n                        clearSelection();\r\n                        notificationService.success(\r\n                            _('catalog.notify-remove-collections-from-channel-success'),\r\n                            {\r\n                                count: selection.length,\r\n                            },\r\n                        );\r\n                        hostComponent.refresh();\r\n                    }\r\n                });\r\n        },\r\n    };\r\n"]}

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

@@ -0,0 +1,154 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, 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 { DataService, ModalService, NotificationService, SelectionManager, ServerConfigService, } from '@vendure/admin-ui/core';
+import { combineLatest, EMPTY, Subject } from 'rxjs';
+import { debounceTime, distinctUntilChanged, map, shareReplay, switchMap, take, takeUntil, tap, } from 'rxjs/operators';
+export class CollectionListComponent {
+    constructor(dataService, notificationService, modalService, router, route, serverConfigService, changeDetectorRef) {
+        this.dataService = dataService;
+        this.notificationService = notificationService;
+        this.modalService = modalService;
+        this.router = router;
+        this.route = route;
+        this.serverConfigService = serverConfigService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.filterTermControl = new FormControl('');
+        this.expandAll = false;
+        this.expandedIds = [];
+        this.destroy$ = new Subject();
+        this.selectionManager = new SelectionManager({
+            additiveMode: true,
+            multiSelect: true,
+            itemsAreEqual: (a, b) => a.id === b.id,
+        });
+    }
+    ngOnInit() {
+        var _a, _b;
+        this.queryResult = this.dataService.collection.getCollections(1000, 0).refetchOnChannelChange();
+        this.items$ = this.queryResult
+            .mapStream(data => data.collections.items)
+            .pipe(tap(items => this.selectionManager.setCurrentItems(items)), shareReplay(1));
+        this.activeCollectionId$ = this.route.paramMap.pipe(map(pm => pm.get('contents')), distinctUntilChanged());
+        this.expandedIds = (_b = (_a = this.route.snapshot.queryParamMap.get('expanded')) === null || _a === void 0 ? void 0 : _a.split(',')) !== null && _b !== void 0 ? _b : [];
+        this.expandAll = this.route.snapshot.queryParamMap.get('expanded') === 'all';
+        this.activeCollectionTitle$ = combineLatest(this.activeCollectionId$, this.items$).pipe(map(([id, collections]) => {
+            if (id) {
+                const match = collections.find(c => c.id === id);
+                return match ? match.name : '';
+            }
+            return '';
+        }));
+        this.availableLanguages$ = this.serverConfigService.getAvailableLanguages();
+        this.contentLanguage$ = this.dataService.client
+            .uiState()
+            .mapStream(({ uiState }) => uiState.contentLanguage)
+            .pipe(tap(() => this.refresh()));
+        this.filterTermControl.valueChanges
+            .pipe(debounceTime(250), takeUntil(this.destroy$))
+            .subscribe(term => {
+            this.router.navigate(['./'], {
+                queryParams: {
+                    q: term || undefined,
+                },
+                queryParamsHandling: 'merge',
+                relativeTo: this.route,
+            });
+        });
+        this.route.queryParamMap
+            .pipe(map(qpm => qpm.get('q')), distinctUntilChanged(), takeUntil(this.destroy$))
+            .subscribe(() => this.refresh());
+        this.filterTermControl.patchValue(this.route.snapshot.queryParamMap.get('q'));
+    }
+    ngOnDestroy() {
+        this.queryResult.completed$.next();
+        this.destroy$.next(undefined);
+        this.destroy$.complete();
+    }
+    toggleExpandAll() {
+        this.router.navigate(['./'], {
+            queryParams: {
+                expanded: this.expandAll ? 'all' : undefined,
+            },
+            queryParamsHandling: 'merge',
+            relativeTo: this.route,
+        });
+    }
+    onRearrange(event) {
+        this.dataService.collection.moveCollection([event]).subscribe({
+            next: () => {
+                this.notificationService.success(_('common.notify-saved-changes'));
+                this.refresh();
+            },
+            error: err => {
+                this.notificationService.error(_('common.notify-save-changes-error'));
+            },
+        });
+    }
+    deleteCollection(id) {
+        this.items$
+            .pipe(take(1), map(items => -1 < items.findIndex(i => i.parent && i.parent.id === id)), switchMap(hasChildren => {
+            return this.modalService.dialog({
+                title: _('catalog.confirm-delete-collection'),
+                body: hasChildren
+                    ? _('catalog.confirm-delete-collection-and-children-body')
+                    : undefined,
+                buttons: [
+                    { type: 'secondary', label: _('common.cancel') },
+                    { type: 'danger', label: _('common.delete'), returnValue: true },
+                ],
+            });
+        }), switchMap(response => (response ? this.dataService.collection.deleteCollection(id) : EMPTY)))
+            .subscribe(() => {
+            this.notificationService.success(_('common.notify-delete-success'), {
+                entity: 'Collection',
+            });
+            this.refresh();
+        }, err => {
+            this.notificationService.error(_('common.notify-delete-error'), {
+                entity: 'Collection',
+            });
+        });
+    }
+    closeContents() {
+        const params = Object.assign({}, this.route.snapshot.params);
+        delete params.contents;
+        this.router.navigate(['./', params], { relativeTo: this.route, queryParamsHandling: 'preserve' });
+    }
+    setLanguage(code) {
+        this.dataService.client.setContentLanguage(code).subscribe();
+    }
+    refresh() {
+        const filterTerm = this.route.snapshot.queryParamMap.get('q');
+        this.queryResult.ref.refetch({
+            options: Object.assign({ skip: 0, take: 1000 }, (filterTerm
+                ? {
+                    filter: {
+                        name: {
+                            contains: filterTerm,
+                        },
+                    },
+                }
+                : {})),
+        });
+    }
+}
+CollectionListComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-collection-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 class=\"flex center\">\n                <clr-toggle-wrapper\n                    class=\"expand-all-toggle mt2\"\n                >\n                    <input type=\"checkbox\" clrToggle [(ngModel)]=\"expandAll\" (change)=\"toggleExpandAll()\" />\n                    <label>\n                        {{ 'catalog.expand-all-collections' | translate }}\n                    </label>\n                </clr-toggle-wrapper>\n                <vdr-language-selector\n                    class=\"mt2\"\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=\"collection-list\"></vdr-action-bar-items>\n        <a\n            class=\"btn btn-primary\"\n            *vdrIfPermissions=\"['CreateCatalog', 'CreateCollection']\"\n            [routerLink]=\"['./create']\"\n        >\n            <clr-icon shape=\"plus\"></clr-icon>\n            {{ 'catalog.create-new-collection' | translate }}\n        </a>\n    </vdr-ab-right>\n</vdr-action-bar>\n<div class=\"bulk-select-controls\">\n    <input\n        type=\"checkbox\"\n        clrCheckbox\n        [checked]=\"selectionManager.areAllCurrentItemsSelected()\"\n        (click)=\"selectionManager.toggleSelectAll()\"\n    />\n    <vdr-bulk-action-menu\n        class=\"ml2\"\n        locationId=\"collection-list\"\n        [hostComponent]=\"this\"\n        [selectionManager]=\"selectionManager\"\n    ></vdr-bulk-action-menu>\n</div>\n<div class=\"collection-wrapper\">\n    <vdr-collection-tree\n        [collections]=\"items$ | async\"\n        [activeCollectionId]=\"activeCollectionId$ | async\"\n        [expandAll]=\"expandAll\"\n        [expandedIds]=\"expandedIds\"\n        [selectionManager]=\"selectionManager\"\n        (rearrange)=\"onRearrange($event)\"\n        (deleteCollection)=\"deleteCollection($event)\"\n    ></vdr-collection-tree>\n\n    <div class=\"collection-contents\" [class.expanded]=\"activeCollectionId$ | async\">\n        <vdr-collection-contents [collectionId]=\"activeCollectionId$ | async\">\n            <ng-template let-count>\n                <div class=\"collection-title\">\n                    {{ activeCollectionTitle$ | async }} ({{\n                        'common.results-count' | translate: { count: count }\n                    }})\n                </div>\n                <button type=\"button\" class=\"close-button\" (click)=\"closeContents()\">\n                    <clr-icon shape=\"close\"></clr-icon>\n                </button>\n            </ng-template>\n        </vdr-collection-contents>\n    </div>\n</div>\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [":host{height:100%;display:flex;flex-direction:column}.bulk-select-controls{min-height:36px;padding-left:14px;display:flex;align-items:center;border-bottom:1px solid var(--color-component-border-200)}.expand-all-toggle{display:block}.collection-wrapper{display:flex;height:calc(100% - 50px)}.collection-wrapper vdr-collection-tree{flex:1;height:100%;overflow:auto}.collection-wrapper .collection-contents{height:100%;width:0;opacity:0;visibility:hidden;overflow:auto;transition:width .3s,opacity .2s .3s,visibility 0s .3s}.collection-wrapper .collection-contents.expanded{width:30vw;visibility:visible;opacity:1;padding-left:12px}.collection-wrapper .collection-contents .close-button{margin:0;background:none;border:none;cursor:pointer}.paging-controls{padding-top:6px;border-top:1px solid var(--color-component-border-100);display:flex;justify-content:space-between}\n"]
+            },] }
+];
+CollectionListComponent.ctorParameters = () => [
+    { type: DataService },
+    { type: NotificationService },
+    { type: ModalService },
+    { type: Router },
+    { type: ActivatedRoute },
+    { type: ServerConfigService },
+    { type: ChangeDetectorRef }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection-list.component.js","sourceRoot":"","sources":["../../../../../src/lib/catalog/src/components/collection-list/collection-list.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, OnDestroy, 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    DataService,\r\n    GetCollectionList,\r\n    LanguageCode,\r\n    ModalService,\r\n    NotificationService,\r\n    QueryResult,\r\n    SelectionManager,\r\n    ServerConfigService,\r\n} from '@vendure/admin-ui/core';\r\nimport { combineLatest, EMPTY, Observable, Subject } from 'rxjs';\r\nimport {\r\n    debounceTime,\r\n    distinctUntilChanged,\r\n    map,\r\n    shareReplay,\r\n    switchMap,\r\n    take,\r\n    takeUntil,\r\n    tap,\r\n} from 'rxjs/operators';\r\n\r\nimport { CollectionPartial, RearrangeEvent } from '../collection-tree/collection-tree.component';\r\n\r\n@Component({\r\n    selector: 'vdr-collection-list',\r\n    templateUrl: './collection-list.component.html',\r\n    styleUrls: ['./collection-list.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class CollectionListComponent implements OnInit, OnDestroy {\r\n    filterTermControl = new FormControl('');\r\n    activeCollectionId$: Observable<string | null>;\r\n    activeCollectionTitle$: Observable<string>;\r\n    items$: Observable<GetCollectionList.Items[]>;\r\n    availableLanguages$: Observable<LanguageCode[]>;\r\n    contentLanguage$: Observable<LanguageCode>;\r\n    expandAll = false;\r\n    expandedIds: string[] = [];\r\n    selectionManager: SelectionManager<CollectionPartial>;\r\n    private queryResult: QueryResult<any>;\r\n    private destroy$ = new Subject<void>();\r\n\r\n    constructor(\r\n        private dataService: DataService,\r\n        private notificationService: NotificationService,\r\n        private modalService: ModalService,\r\n        private router: Router,\r\n        private route: ActivatedRoute,\r\n        private serverConfigService: ServerConfigService,\r\n        private changeDetectorRef: ChangeDetectorRef,\r\n    ) {\r\n        this.selectionManager = new SelectionManager({\r\n            additiveMode: true,\r\n            multiSelect: true,\r\n            itemsAreEqual: (a, b) => a.id === b.id,\r\n        });\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.queryResult = this.dataService.collection.getCollections(1000, 0).refetchOnChannelChange();\r\n        this.items$ = this.queryResult\r\n            .mapStream(data => data.collections.items)\r\n            .pipe(\r\n                tap(items => this.selectionManager.setCurrentItems(items)),\r\n                shareReplay(1),\r\n            );\r\n        this.activeCollectionId$ = this.route.paramMap.pipe(\r\n            map(pm => pm.get('contents')),\r\n            distinctUntilChanged(),\r\n        );\r\n        this.expandedIds = this.route.snapshot.queryParamMap.get('expanded')?.split(',') ?? [];\r\n        this.expandAll = this.route.snapshot.queryParamMap.get('expanded') === 'all';\r\n\r\n        this.activeCollectionTitle$ = combineLatest(this.activeCollectionId$, this.items$).pipe(\r\n            map(([id, collections]) => {\r\n                if (id) {\r\n                    const match = collections.find(c => c.id === id);\r\n                    return match ? match.name : '';\r\n                }\r\n                return '';\r\n            }),\r\n        );\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\r\n        this.filterTermControl.valueChanges\r\n            .pipe(debounceTime(250), takeUntil(this.destroy$))\r\n            .subscribe(term => {\r\n                this.router.navigate(['./'], {\r\n                    queryParams: {\r\n                        q: term || undefined,\r\n                    },\r\n                    queryParamsHandling: 'merge',\r\n                    relativeTo: this.route,\r\n                });\r\n            });\r\n\r\n        this.route.queryParamMap\r\n            .pipe(\r\n                map(qpm => qpm.get('q')),\r\n                distinctUntilChanged(),\r\n                takeUntil(this.destroy$),\r\n            )\r\n            .subscribe(() => this.refresh());\r\n        this.filterTermControl.patchValue(this.route.snapshot.queryParamMap.get('q'));\r\n    }\r\n\r\n    ngOnDestroy() {\r\n        this.queryResult.completed$.next();\r\n        this.destroy$.next(undefined);\r\n        this.destroy$.complete();\r\n    }\r\n\r\n    toggleExpandAll() {\r\n        this.router.navigate(['./'], {\r\n            queryParams: {\r\n                expanded: this.expandAll ? 'all' : undefined,\r\n            },\r\n            queryParamsHandling: 'merge',\r\n            relativeTo: this.route,\r\n        });\r\n    }\r\n\r\n    onRearrange(event: RearrangeEvent) {\r\n        this.dataService.collection.moveCollection([event]).subscribe({\r\n            next: () => {\r\n                this.notificationService.success(_('common.notify-saved-changes'));\r\n                this.refresh();\r\n            },\r\n            error: err => {\r\n                this.notificationService.error(_('common.notify-save-changes-error'));\r\n            },\r\n        });\r\n    }\r\n\r\n    deleteCollection(id: string) {\r\n        this.items$\r\n            .pipe(\r\n                take(1),\r\n                map(items => -1 < items.findIndex(i => i.parent && i.parent.id === id)),\r\n                switchMap(hasChildren => {\r\n                    return this.modalService.dialog({\r\n                        title: _('catalog.confirm-delete-collection'),\r\n                        body: hasChildren\r\n                            ? _('catalog.confirm-delete-collection-and-children-body')\r\n                            : undefined,\r\n                        buttons: [\r\n                            { type: 'secondary', label: _('common.cancel') },\r\n                            { type: 'danger', label: _('common.delete'), returnValue: true },\r\n                        ],\r\n                    });\r\n                }),\r\n                switchMap(response => (response ? this.dataService.collection.deleteCollection(id) : EMPTY)),\r\n            )\r\n            .subscribe(\r\n                () => {\r\n                    this.notificationService.success(_('common.notify-delete-success'), {\r\n                        entity: 'Collection',\r\n                    });\r\n                    this.refresh();\r\n                },\r\n                err => {\r\n                    this.notificationService.error(_('common.notify-delete-error'), {\r\n                        entity: 'Collection',\r\n                    });\r\n                },\r\n            );\r\n    }\r\n\r\n    closeContents() {\r\n        const params = { ...this.route.snapshot.params };\r\n        delete params.contents;\r\n        this.router.navigate(['./', params], { relativeTo: this.route, queryParamsHandling: 'preserve' });\r\n    }\r\n\r\n    setLanguage(code: LanguageCode) {\r\n        this.dataService.client.setContentLanguage(code).subscribe();\r\n    }\r\n\r\n    refresh() {\r\n        const filterTerm = this.route.snapshot.queryParamMap.get('q');\r\n        this.queryResult.ref.refetch({\r\n            options: {\r\n                skip: 0,\r\n                take: 1000,\r\n                ...(filterTerm\r\n                    ? {\r\n                          filter: {\r\n                              name: {\r\n                                  contains: filterTerm,\r\n                              },\r\n                          },\r\n                      }\r\n                    : {}),\r\n            },\r\n        });\r\n    }\r\n}\r\n"]}

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

@@ -0,0 +1,126 @@
+import { moveItemInArray } from '@angular/cdk/drag-drop';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, Optional, SkipSelf, } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { DataService, Permission } from '@vendure/admin-ui/core';
+import { map, shareReplay } from 'rxjs/operators';
+import { CollectionTreeComponent } from './collection-tree.component';
+export class CollectionTreeNodeComponent {
+    constructor(parent, root, dataService, router, route, changeDetectorRef) {
+        this.parent = parent;
+        this.root = root;
+        this.dataService = dataService;
+        this.router = router;
+        this.route = route;
+        this.changeDetectorRef = changeDetectorRef;
+        this.depth = 0;
+        this.expandAll = false;
+        this.moveListItems = [];
+        if (parent) {
+            this.depth = parent.depth + 1;
+        }
+    }
+    ngOnInit() {
+        var _a;
+        this.parentName = this.collectionTree.name || '<root>';
+        const permissions$ = this.dataService.client
+            .userStatus()
+            .mapStream(data => data.userStatus.permissions)
+            .pipe(shareReplay(1));
+        this.hasUpdatePermission$ = permissions$.pipe(map(perms => perms.includes(Permission.UpdateCatalog) || perms.includes(Permission.UpdateCollection)));
+        this.hasDeletePermission$ = permissions$.pipe(map(perms => perms.includes(Permission.DeleteCatalog) || perms.includes(Permission.DeleteCollection)));
+        this.subscription = (_a = this.selectionManager) === null || _a === void 0 ? void 0 : _a.selectionChanges$.subscribe(() => this.changeDetectorRef.markForCheck());
+    }
+    ngOnChanges(changes) {
+        const expandAllChange = changes['expandAll'];
+        if (expandAllChange) {
+            if (expandAllChange.previousValue === true && expandAllChange.currentValue === false) {
+                this.collectionTree.children.forEach(c => (c.expanded = false));
+            }
+        }
+    }
+    ngOnDestroy() {
+        var _a;
+        (_a = this.subscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    }
+    trackByFn(index, item) {
+        return item.id;
+    }
+    toggleExpanded(collection) {
+        var _a, _b;
+        collection.expanded = !collection.expanded;
+        let expandedIds = (_b = (_a = this.route.snapshot.queryParamMap.get('expanded')) === null || _a === void 0 ? void 0 : _a.split(',')) !== null && _b !== void 0 ? _b : [];
+        if (collection.expanded) {
+            expandedIds.push(collection.id);
+        }
+        else {
+            expandedIds = expandedIds.filter(id => id !== collection.id);
+        }
+        this.router.navigate(['./'], {
+            queryParams: {
+                expanded: expandedIds.filter(id => !!id).join(','),
+            },
+            queryParamsHandling: 'merge',
+            relativeTo: this.route,
+        });
+    }
+    getMoveListItems(collection) {
+        this.moveListItems = this.root.getMoveListItems(collection);
+    }
+    move(collection, parentId) {
+        this.root.onMove({
+            index: 0,
+            parentId,
+            collectionId: collection.id,
+        });
+    }
+    moveUp(collection, currentIndex) {
+        if (!collection.parent) {
+            return;
+        }
+        this.root.onMove({
+            index: currentIndex - 1,
+            parentId: collection.parent.id,
+            collectionId: collection.id,
+        });
+    }
+    moveDown(collection, currentIndex) {
+        if (!collection.parent) {
+            return;
+        }
+        this.root.onMove({
+            index: currentIndex + 1,
+            parentId: collection.parent.id,
+            collectionId: collection.id,
+        });
+    }
+    drop(event) {
+        moveItemInArray(this.collectionTree.children, event.previousIndex, event.currentIndex);
+        this.root.onDrop(event);
+    }
+    delete(id) {
+        this.root.onDelete(id);
+    }
+}
+CollectionTreeNodeComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-collection-tree-node',
+                template: "<div\r\n    cdkDropList\r\n    class=\"tree-node\"\r\n    #dropList\r\n    [cdkDropListData]=\"collectionTree\"\r\n    [cdkDropListDisabled]=\"!(hasUpdatePermission$ | async)\"\r\n    (cdkDropListDropped)=\"drop($event)\"\r\n>\r\n    <div\r\n        class=\"collection\"\r\n        [class.private]=\"collection.isPrivate\"\r\n        *ngFor=\"let collection of collectionTree.children; index as i; trackBy: trackByFn\"\r\n        cdkDrag\r\n        [cdkDragData]=\"collection\"\r\n    >\r\n        <div\r\n            class=\"collection-detail\"\r\n            [ngClass]=\"'depth-' + depth\"\r\n            [class.active]=\"collection.id === activeCollectionId\"\r\n        >\r\n            <div>\r\n                <input\r\n                    type=\"checkbox\"\r\n                    clrCheckbox\r\n                    [checked]=\"selectionManager.isSelected(collection)\"\r\n                    (click)=\"selectionManager.toggleSelection(collection, $event)\"\r\n                />\r\n            </div>\r\n            <div class=\"name\">\r\n                <button\r\n                    class=\"icon-button folder-button\"\r\n                    [disabled]=\"expandAll\"\r\n                    *ngIf=\"collection.children?.length; else folderSpacer\"\r\n                    (click)=\"toggleExpanded(collection)\"\r\n                >\r\n                    <clr-icon shape=\"folder\" *ngIf=\"!collection.expanded && !expandAll\"></clr-icon>\r\n                    <clr-icon shape=\"folder-open\" *ngIf=\"collection.expanded || expandAll\"></clr-icon>\r\n                </button>\r\n                <ng-template #folderSpacer>\r\n                    <div class=\"folder-button-spacer\"></div>\r\n                </ng-template>\r\n                {{ collection.name }}\r\n            </div>\r\n            <div class=\"flex-spacer\"></div>\r\n            <vdr-chip *ngIf=\"collection.isPrivate\">{{ 'catalog.private' | translate }}</vdr-chip>\r\n            <a\r\n                class=\"btn btn-link btn-sm\"\r\n                [routerLink]=\"['./', { contents: collection.id }]\"\r\n                queryParamsHandling=\"preserve\"\r\n            >\r\n                <clr-icon shape=\"view-list\"></clr-icon>\r\n                {{ 'catalog.view-contents' | translate }}\r\n            </a>\r\n            <a class=\"btn btn-link btn-sm\" [routerLink]=\"['/catalog/collections/', collection.id]\">\r\n                <clr-icon shape=\"edit\"></clr-icon>\r\n                {{ 'common.edit' | translate }}\r\n            </a>\r\n            <div class=\"drag-handle\" cdkDragHandle *vdrIfPermissions=\"['UpdateCatalog', 'UpdateCollection']\">\r\n                <clr-icon shape=\"drag-handle\" size=\"24\"></clr-icon>\r\n            </div>\r\n            <vdr-dropdown>\r\n                <button class=\"icon-button\" vdrDropdownTrigger (click)=\"getMoveListItems(collection)\">\r\n                    <clr-icon shape=\"ellipsis-vertical\"></clr-icon>\r\n                </button>\r\n                <vdr-dropdown-menu vdrPosition=\"bottom-right\">\r\n                    <a\r\n                        class=\"dropdown-item\"\r\n                        [routerLink]=\"['./', 'create', { parentId: collection.id }]\"\r\n                        *vdrIfPermissions=\"['CreateCatalog', 'CreateCollection']\"\r\n                    >\r\n                        <clr-icon shape=\"plus\"></clr-icon>\r\n                        {{ 'catalog.create-new-collection' | translate }}\r\n                    </a>\r\n                    <div class=\"dropdown-divider\"></div>\r\n                    <button\r\n                        type=\"button\"\r\n                        vdrDropdownItem\r\n                        [disabled]=\"i === 0 || !(hasUpdatePermission$ | async)\"\r\n                        (click)=\"moveUp(collection, i)\"\r\n                    >\r\n                        <clr-icon shape=\"caret up\"></clr-icon>\r\n                        {{ 'catalog.move-up' | translate }}\r\n                    </button>\r\n                    <button\r\n                        type=\"button\"\r\n                        vdrDropdownItem\r\n                        [disabled]=\"\r\n                            i === collectionTree.children.length - 1 || !(hasUpdatePermission$ | async)\r\n                        \"\r\n                        (click)=\"moveDown(collection, i)\"\r\n                    >\r\n                        <clr-icon shape=\"caret down\"></clr-icon>\r\n                        {{ 'catalog.move-down' | translate }}\r\n                    </button>\r\n                    <h4 class=\"dropdown-header\">{{ 'catalog.move-to' | translate }}</h4>\r\n                    <button\r\n                        type=\"button\"\r\n                        vdrDropdownItem\r\n                        *ngFor=\"let item of moveListItems\"\r\n                        (click)=\"move(collection, item.id)\"\r\n                        [disabled]=\"!(hasUpdatePermission$ | async)\"\r\n                    >\r\n                        <div class=\"move-to-item\">\r\n                            <div class=\"move-icon\">\r\n                                <clr-icon shape=\"child-arrow\"></clr-icon>\r\n                            </div>\r\n                            <div class=\"path\">\r\n                                {{ item.path }}\r\n                            </div>\r\n                        </div>\r\n                    </button>\r\n                    <div class=\"dropdown-divider\"></div>\r\n                    <button\r\n                        class=\"button\"\r\n                        vdrDropdownItem\r\n                        (click)=\"delete(collection.id)\"\r\n                        [disabled]=\"!(hasDeletePermission$ | async)\"\r\n                    >\r\n                        <clr-icon shape=\"trash\" class=\"is-danger\"></clr-icon>\r\n                        {{ 'common.delete' | translate }}\r\n                    </button>\r\n                </vdr-dropdown-menu>\r\n            </vdr-dropdown>\r\n        </div>\r\n        <vdr-collection-tree-node\r\n            *ngIf=\"collection.expanded || expandAll\"\r\n            [expandAll]=\"expandAll\"\r\n            [collectionTree]=\"collection\"\r\n            [activeCollectionId]=\"activeCollectionId\"\r\n            [selectionManager]=\"selectionManager\"\r\n        ></vdr-collection-tree-node>\r\n    </div>\r\n</div>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [":host{display:block}.collection{background-color:var(--clr-table-bgcolor);border-radius:var(--clr-global-borderradius);font-size:.65rem;transition:transform .25s cubic-bezier(0,0,.2,1);margin-bottom:2px;border-left:2px solid transparent;transition:border-left-color .2s}.collection.private{background-color:var(--color-component-bg-200)}.collection .collection-detail{padding:6px 12px;display:flex;align-items:center;justify-content:space-between;border-bottom:1px solid var(--color-component-border-100)}.collection .collection-detail.active{background-color:var(--clr-global-selection-color)}.collection .collection-detail.depth-1{padding-left:36px}.collection .collection-detail.depth-2{padding-left:60px}.collection .collection-detail.depth-3{padding-left:84px}.collection .collection-detail.depth-4{padding-left:108px}.collection .collection-detail .folder-button-spacer{display:inline-block;width:28px}.tree-node{display:block;background-color:var(--clr-table-bgcolor);border-radius:var(--clr-global-borderradius);overflow:hidden}.tree-node.cdk-drop-list-dragging>.collection{border-left-color:var(--color-primary-300)}.drag-placeholder{min-height:120px;background-color:var(--color-component-bg-300);transition:transform .25s cubic-bezier(0,0,.2,1)}.cdk-drag-preview{box-sizing:border-box;border-radius:4px;box-shadow:0 5px 5px -3px #0003,0 8px 10px 1px #00000024,0 3px 14px 2px #0000001f}.cdk-drag-placeholder{opacity:0}.cdk-drag-animating{transition:transform .25s cubic-bezier(0,0,.2,1)}.example-list.cdk-drop-list-dragging .tree-node:not(.cdk-drag-placeholder){transition:transform .25s cubic-bezier(0,0,.2,1)}.move-to-item{display:flex;white-space:normal;align-items:baseline}.move-to-item .move-icon{flex:none;margin-right:3px}.move-to-item .path{line-height:18px}\n"]
+            },] }
+];
+CollectionTreeNodeComponent.ctorParameters = () => [
+    { type: CollectionTreeNodeComponent, decorators: [{ type: SkipSelf }, { type: Optional }] },
+    { type: CollectionTreeComponent },
+    { type: DataService },
+    { type: Router },
+    { type: ActivatedRoute },
+    { type: ChangeDetectorRef }
+];
+CollectionTreeNodeComponent.propDecorators = {
+    collectionTree: [{ type: Input }],
+    activeCollectionId: [{ type: Input }],
+    expandAll: [{ type: Input }],
+    selectionManager: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection-tree-node.component.js","sourceRoot":"","sources":["../../../../../src/lib/catalog/src/components/collection-tree/collection-tree-node.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkDragDrop, moveItemInArray } from '@angular/cdk/drag-drop';\r\nimport {\r\n    ChangeDetectionStrategy,\r\n    ChangeDetectorRef,\r\n    Component,\r\n    Input,\r\n    OnChanges,\r\n    OnDestroy,\r\n    OnInit,\r\n    Optional,\r\n    SimpleChanges,\r\n    SkipSelf,\r\n} from '@angular/core';\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { DataService, Permission, SelectionManager } from '@vendure/admin-ui/core';\r\nimport { Observable, Subscription } from 'rxjs';\r\nimport { map, shareReplay } from 'rxjs/operators';\r\n\r\nimport { RootNode, TreeNode } from './array-to-tree';\r\nimport { CollectionPartial, CollectionTreeComponent } from './collection-tree.component';\r\n\r\n@Component({\r\n    selector: 'vdr-collection-tree-node',\r\n    templateUrl: './collection-tree-node.component.html',\r\n    styleUrls: ['./collection-tree-node.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class CollectionTreeNodeComponent implements OnInit, OnChanges, OnDestroy {\r\n    depth = 0;\r\n    parentName: string;\r\n    @Input() collectionTree: TreeNode<CollectionPartial>;\r\n    @Input() activeCollectionId: string;\r\n    @Input() expandAll = false;\r\n    @Input() selectionManager: SelectionManager<CollectionPartial>;\r\n    hasUpdatePermission$: Observable<boolean>;\r\n    hasDeletePermission$: Observable<boolean>;\r\n    moveListItems: Array<{ path: string; id: string }> = [];\r\n    private subscription: Subscription;\r\n\r\n    constructor(\r\n        @SkipSelf() @Optional() private parent: CollectionTreeNodeComponent,\r\n        private root: CollectionTreeComponent,\r\n        private dataService: DataService,\r\n        private router: Router,\r\n        private route: ActivatedRoute,\r\n        private changeDetectorRef: ChangeDetectorRef,\r\n    ) {\r\n        if (parent) {\r\n            this.depth = parent.depth + 1;\r\n        }\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.parentName = this.collectionTree.name || '<root>';\r\n        const permissions$ = this.dataService.client\r\n            .userStatus()\r\n            .mapStream(data => data.userStatus.permissions)\r\n            .pipe(shareReplay(1));\r\n        this.hasUpdatePermission$ = permissions$.pipe(\r\n            map(\r\n                perms =>\r\n                    perms.includes(Permission.UpdateCatalog) || perms.includes(Permission.UpdateCollection),\r\n            ),\r\n        );\r\n        this.hasDeletePermission$ = permissions$.pipe(\r\n            map(\r\n                perms =>\r\n                    perms.includes(Permission.DeleteCatalog) || perms.includes(Permission.DeleteCollection),\r\n            ),\r\n        );\r\n        this.subscription = this.selectionManager?.selectionChanges$.subscribe(() =>\r\n            this.changeDetectorRef.markForCheck(),\r\n        );\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges) {\r\n        const expandAllChange = changes['expandAll'];\r\n        if (expandAllChange) {\r\n            if (expandAllChange.previousValue === true && expandAllChange.currentValue === false) {\r\n                this.collectionTree.children.forEach(c => (c.expanded = false));\r\n            }\r\n        }\r\n    }\r\n\r\n    ngOnDestroy() {\r\n        this.subscription?.unsubscribe();\r\n    }\r\n\r\n    trackByFn(index: number, item: CollectionPartial) {\r\n        return item.id;\r\n    }\r\n\r\n    toggleExpanded(collection: TreeNode<CollectionPartial>) {\r\n        collection.expanded = !collection.expanded;\r\n        let expandedIds = this.route.snapshot.queryParamMap.get('expanded')?.split(',') ?? [];\r\n        if (collection.expanded) {\r\n            expandedIds.push(collection.id);\r\n        } else {\r\n            expandedIds = expandedIds.filter(id => id !== collection.id);\r\n        }\r\n        this.router.navigate(['./'], {\r\n            queryParams: {\r\n                expanded: expandedIds.filter(id => !!id).join(','),\r\n            },\r\n            queryParamsHandling: 'merge',\r\n            relativeTo: this.route,\r\n        });\r\n    }\r\n\r\n    getMoveListItems(collection: CollectionPartial) {\r\n        this.moveListItems = this.root.getMoveListItems(collection);\r\n    }\r\n\r\n    move(collection: CollectionPartial, parentId: string) {\r\n        this.root.onMove({\r\n            index: 0,\r\n            parentId,\r\n            collectionId: collection.id,\r\n        });\r\n    }\r\n\r\n    moveUp(collection: CollectionPartial, currentIndex: number) {\r\n        if (!collection.parent) {\r\n            return;\r\n        }\r\n        this.root.onMove({\r\n            index: currentIndex - 1,\r\n            parentId: collection.parent.id,\r\n            collectionId: collection.id,\r\n        });\r\n    }\r\n\r\n    moveDown(collection: CollectionPartial, currentIndex: number) {\r\n        if (!collection.parent) {\r\n            return;\r\n        }\r\n        this.root.onMove({\r\n            index: currentIndex + 1,\r\n            parentId: collection.parent.id,\r\n            collectionId: collection.id,\r\n        });\r\n    }\r\n\r\n    drop(event: CdkDragDrop<CollectionPartial | RootNode<CollectionPartial>>) {\r\n        moveItemInArray(this.collectionTree.children, event.previousIndex, event.currentIndex);\r\n        this.root.onDrop(event);\r\n    }\r\n\r\n    delete(id: string) {\r\n        this.root.onDelete(id);\r\n    }\r\n}\r\n"]}