ngx-edu-sharing-ui 0.7.0 → 9.0.0

package/esm2022/lib/directives/drag-nodes/nodes-drag-source.directive.mjs

@@ -0,0 +1,79 @@
+import { Directive, EventEmitter, HostListener, Input, Output, } from '@angular/core';
+import { clearDraggedNodes, dragNodesTransferType, saveDraggedNodes } from './drag-nodes';
+import * as i0 from "@angular/core";
+/**
+ * Handle dragging and dropping of node elements.
+ *
+ * Use in combination with `NodesDropTargetDirective`.
+ *
+ * When nodes that set this directive are dragged, we save information about
+ * these nodes that can be used by `NodesDropTargetDirective`.
+ */
+export class NodesDragSourceDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        /**
+         * Triggered when processing the dragstart event.
+         *
+         * Changes to `nodes` performed by event handlers of `nodesDragStart` will
+         * be taken into account for the drag operation.
+         */
+        this.nodesDragStart = new EventEmitter(false);
+        /**
+         * Triggered when processing the dragend event.
+         */
+        this.nodesDragEnd = new EventEmitter();
+    }
+    ngOnChanges(changes) {
+        // Set the `draggable` attribute when this directive is active.
+        if (changes.nodes) {
+            if (!!changes.nodes.currentValue !== !!changes.nodes.previousValue) {
+                this.elementRef.nativeElement.setAttribute('draggable', (!!this.nodes).toString());
+            }
+        }
+    }
+    onDragStart(event) {
+        if (!this.nodes) {
+            return;
+        }
+        this.nodesDragStart.emit(event);
+        // Use the transfer-data type to identify a node-drag operation.
+        event.dataTransfer.setData(dragNodesTransferType, '');
+        // Chrome doesn't provide drag transfer data to dragover event listeners
+        // for security reasons, so we provide the data via localStorage.
+        //
+        // Wait for updates by event handlers of `nodesDragStart` to propagate.
+        setTimeout(() => {
+            saveDraggedNodes(this.nodes);
+        });
+    }
+    onDragEnd(event) {
+        if (!this.nodes) {
+            return;
+        }
+        this.nodesDragEnd.emit(event);
+        clearDraggedNodes();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodesDragSourceDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.6", type: NodesDragSourceDirective, selector: "[esNodesDragSource]", inputs: { nodes: ["esNodesDragSource", "nodes"] }, outputs: { nodesDragStart: "nodesDragStart", nodesDragEnd: "nodesDragEnd" }, host: { listeners: { "dragstart": "onDragStart($event)", "dragend": "onDragEnd($event)" } }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodesDragSourceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[esNodesDragSource]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { nodes: [{
+                type: Input,
+                args: ['esNodesDragSource']
+            }], nodesDragStart: [{
+                type: Output
+            }], nodesDragEnd: [{
+                type: Output
+            }], onDragStart: [{
+                type: HostListener,
+                args: ['dragstart', ['$event']]
+            }], onDragEnd: [{
+                type: HostListener,
+                args: ['dragend', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/drag-nodes/nodes-drag.directive.mjs

@@ -0,0 +1,49 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/drag-drop";
+import * as i2 from "../../services/nodes-drag-drop.service";
+/**
+ * A draggable node.
+ *
+ * Use in combination with `cdkDrag`, setting `cdkDragData` to the array of nodes to be dragged.
+ */
+export class NodesDragDirective {
+    constructor(cdkDrag, nodesDragDrop) {
+        this.cdkDrag = cdkDrag;
+        this.nodesDragDrop = nodesDragDrop;
+        this.cdkDrag.started.subscribe((event) => {
+            this.nodesDragDrop.draggedNodes = event.source.data;
+            // Position the preview element (the one being dragged around) next to the cursor to
+            // avoid covering possible drop targets with the preview.
+            event.source._dragRef['_pickupPositionInElement'] = { x: 0, y: 0 };
+        });
+        this.cdkDrag.released.subscribe(() => {
+            if (this.nodesDragDrop.canDrop?.accept) {
+                this.inhibitPreviewAnimation();
+            }
+        });
+        this.cdkDrag.dropped.subscribe(() => {
+            this.nodesDragDrop.onDropped(this.cdkDrag.data);
+            this.nodesDragDrop.draggedNodes = null;
+        });
+    }
+    inhibitPreviewAnimation() {
+        const style = document.createElement('style');
+        document.body.appendChild(style);
+        style.innerHTML = `.cdk-drag-preview { transition: none !important; }`;
+        // Don't need to go outside ng zone because `cdkDrag.released` already runs outside the
+        // zone.
+        setTimeout(() => {
+            document.body.removeChild(style);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodesDragDirective, deps: [{ token: i1.CdkDrag }, { token: i2.NodesDragDropService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.6", type: NodesDragDirective, selector: "[esNodesDrag]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodesDragDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[esNodesDrag]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CdkDrag }, { type: i2.NodesDragDropService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/drag-nodes/nodes-drop-target.directive.mjs

@@ -0,0 +1,105 @@
+import { Directive, EventEmitter, Input, Output, } from '@angular/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/nodes-drag-drop.service";
+const ACTIVE_DROP_TARGET_ACCEPT_CLASS = 'es-nodes-active-drop-target-accept';
+const ACTIVE_DROP_TARGET_DENY_CLASS = 'es-nodes-active-drop-target-deny';
+export class NodesDropTargetDirective {
+    get active() {
+        return this.activeDropTargetSubject.value;
+    }
+    constructor(ngZone, elementRef, nodesDragDrop) {
+        this.ngZone = ngZone;
+        this.elementRef = elementRef;
+        this.nodesDragDrop = nodesDragDrop;
+        this.nodeDropped = new EventEmitter();
+        this.activeDropTargetSubject = new BehaviorSubject(null);
+        this.destroyed = new Subject();
+        this.registerMouseEnterLeave();
+        this.registerActiveDropTarget();
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    _setActiveDropTarget(value) {
+        this.activeDropTargetSubject.next(value);
+    }
+    registerMouseEnterLeave() {
+        this.ngZone.runOutsideAngular(() => {
+            this.elementRef.nativeElement.addEventListener('mouseenter', () => this.nodesDragDrop.onMouseEnter(this));
+            this.elementRef.nativeElement.addEventListener('mouseleave', () => this.nodesDragDrop.onMouseLeave(this));
+            // Firefox does not fire a mouseleave event when the element is removed from the DOM
+            // while being hovered. When an element is dragged, it will be replaced with a
+            // placeholder. If the element was also a drop target, we would think that we are still
+            // hovering the element.
+            observeRemovedFromParent(this.elementRef.nativeElement)
+                .pipe(takeUntil(this.destroyed))
+                .subscribe(() => this.nodesDragDrop.onMouseLeave(this));
+        });
+    }
+    registerActiveDropTarget() {
+        this.activeDropTargetSubject
+            .pipe(takeUntil(this.destroyed))
+            .subscribe((dropTargetState) => {
+            const canDrop = dropTargetState?.canDrop;
+            const classList = this.elementRef.nativeElement.classList;
+            classList.remove(ACTIVE_DROP_TARGET_ACCEPT_CLASS, ACTIVE_DROP_TARGET_DENY_CLASS);
+            if (canDrop?.accept) {
+                classList.add(ACTIVE_DROP_TARGET_ACCEPT_CLASS);
+            }
+            else if (canDrop?.denyExplicit) {
+                classList.add(ACTIVE_DROP_TARGET_DENY_CLASS);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodesDropTargetDirective, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: i1.NodesDragDropService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.6", type: NodesDropTargetDirective, selector: "[esNodesDropTarget]", inputs: { target: ["esNodesDropTarget", "target"], canDropNodes: "canDropNodes" }, outputs: { nodeDropped: "nodeDropped" }, exportAs: ["esNodesDropTarget"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: NodesDropTargetDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[esNodesDropTarget]',
+                    exportAs: 'esNodesDropTarget',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: i1.NodesDragDropService }]; }, propDecorators: { target: [{
+                type: Input,
+                args: ['esNodesDropTarget']
+            }], canDropNodes: [{
+                type: Input
+            }], nodeDropped: [{
+                type: Output
+            }] } });
+function observeRemovedFromParent(element) {
+    return new Observable((subscriber) => {
+        const observer = new MutationObserver((event) => {
+            for (const mutation of event) {
+                // @ts-ignore
+                if ([...mutation.removedNodes].includes(element)) {
+                    subscriber.next();
+                }
+            }
+        });
+        // Wait for `element` to be attached to the DOM.
+        let timeout = setTimeout(() => {
+            timeout = null;
+            observer.observe(element.parentNode, { childList: true, subtree: false });
+        });
+        return () => {
+            // In case the element was destroyed before we attached the mutation observer, we cancel
+            // the observable returned by this function and don't attach the mutation observer.
+            if (timeout !== null) {
+                // TODO: Investigate elements that trigger the following warning.
+                //
+                // console.warn(
+                //     'Possible performance leak: the element got destroyed before it could be added to the DOM.',
+                //     element,
+                // );
+                clearTimeout(timeout);
+            }
+            observer.disconnect();
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodes-drop-target.directive.js","sourceRoot":"","sources":["../../../../../../projects/edu-sharing-ui/src/lib/directives/drag-nodes/nodes-drop-target.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Directive,\n    ElementRef,\n    EventEmitter,\n    Input,\n    NgZone,\n    OnDestroy,\n    Output,\n} from '@angular/core';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { CanDrop, DragData, DropTargetState } from '../../types/drag-drop';\nimport { NodesDragDropService } from '../../services/nodes-drag-drop.service';\n\nconst ACTIVE_DROP_TARGET_ACCEPT_CLASS = 'es-nodes-active-drop-target-accept';\nconst ACTIVE_DROP_TARGET_DENY_CLASS = 'es-nodes-active-drop-target-deny';\n\n@Directive({\n    selector: '[esNodesDropTarget]',\n    exportAs: 'esNodesDropTarget',\n})\nexport class NodesDropTargetDirective<T = unknown> implements OnDestroy {\n    @Input('esNodesDropTarget') target: T;\n    @Input() canDropNodes: (dragData: DragData<T>) => CanDrop;\n    @Output() nodeDropped = new EventEmitter<DragData<T>>();\n\n    get active() {\n        return this.activeDropTargetSubject.value;\n    }\n\n    private activeDropTargetSubject = new BehaviorSubject<DropTargetState | null>(null);\n    private destroyed = new Subject<void>();\n\n    constructor(\n        private ngZone: NgZone,\n        private elementRef: ElementRef<HTMLElement>,\n        private nodesDragDrop: NodesDragDropService,\n    ) {\n        this.registerMouseEnterLeave();\n        this.registerActiveDropTarget();\n    }\n\n    ngOnDestroy(): void {\n        this.destroyed.next();\n        this.destroyed.complete();\n    }\n\n    _setActiveDropTarget(value: DropTargetState | null) {\n        this.activeDropTargetSubject.next(value);\n    }\n\n    private registerMouseEnterLeave() {\n        this.ngZone.runOutsideAngular(() => {\n            this.elementRef.nativeElement.addEventListener('mouseenter', () =>\n                this.nodesDragDrop.onMouseEnter(this),\n            );\n            this.elementRef.nativeElement.addEventListener('mouseleave', () =>\n                this.nodesDragDrop.onMouseLeave(this),\n            );\n            // Firefox does not fire a mouseleave event when the element is removed from the DOM\n            // while being hovered. When an element is dragged, it will be replaced with a\n            // placeholder. If the element was also a drop target, we would think that we are still\n            // hovering the element.\n            observeRemovedFromParent(this.elementRef.nativeElement)\n                .pipe(takeUntil(this.destroyed))\n                .subscribe(() => this.nodesDragDrop.onMouseLeave(this));\n        });\n    }\n\n    private registerActiveDropTarget() {\n        this.activeDropTargetSubject\n            .pipe(takeUntil(this.destroyed))\n            .subscribe((dropTargetState) => {\n                const canDrop = dropTargetState?.canDrop;\n                const classList = this.elementRef.nativeElement.classList;\n                classList.remove(ACTIVE_DROP_TARGET_ACCEPT_CLASS, ACTIVE_DROP_TARGET_DENY_CLASS);\n                if (canDrop?.accept) {\n                    classList.add(ACTIVE_DROP_TARGET_ACCEPT_CLASS);\n                } else if (canDrop?.denyExplicit) {\n                    classList.add(ACTIVE_DROP_TARGET_DENY_CLASS);\n                }\n            });\n    }\n}\n\nfunction observeRemovedFromParent(element: HTMLElement): Observable<void> {\n    return new Observable((subscriber) => {\n        const observer = new MutationObserver((event) => {\n            for (const mutation of event) {\n                // @ts-ignore\n                if ([...mutation.removedNodes].includes(element)) {\n                    subscriber.next();\n                }\n            }\n        });\n        // Wait for `element` to be attached to the DOM.\n        let timeout = setTimeout(() => {\n            timeout = null;\n            observer.observe(element.parentNode, { childList: true, subtree: false });\n        });\n        return () => {\n            // In case the element was destroyed before we attached the mutation observer, we cancel\n            // the observable returned by this function and don't attach the mutation observer.\n            if (timeout !== null) {\n                // TODO: Investigate elements that trigger the following warning.\n                //\n                // console.warn(\n                //     'Possible performance leak: the element got destroyed before it could be added to the DOM.',\n                //     element,\n                // );\n                clearTimeout(timeout);\n            }\n            observer.disconnect();\n        };\n    });\n}\n"]}

package/esm2022/lib/directives/focus-state.directive.mjs

@@ -0,0 +1,44 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FocusStateDirective {
+    constructor() {
+        /** Either the element or one of its descendants has focus. */
+        this.hasFocus = false;
+        /** The element is being hovered with the cursor. */
+        this.hovering = false;
+    }
+    onFocusIn() {
+        this.hasFocus = true;
+    }
+    onFocusOut() {
+        this.hasFocus = false;
+    }
+    onMouseOver() {
+        this.hovering = true;
+    }
+    onMouseOut() {
+        this.hovering = false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: FocusStateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.6", type: FocusStateDirective, selector: "[esFocusState]", host: { listeners: { "focusin": "onFocusIn()", "focusout": "onFocusOut()", "mouseenter": "onMouseOver()", "mouseleave": "onMouseOut()" } }, exportAs: ["esFocusState"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: FocusStateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[esFocusState]',
+                    exportAs: 'esFocusState',
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { onFocusIn: [{
+                type: HostListener,
+                args: ['focusin']
+            }], onFocusOut: [{
+                type: HostListener,
+                args: ['focusout']
+            }], onMouseOver: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseOut: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/icon.directive.mjs

@@ -0,0 +1,139 @@
+/**
+ * Created by Torsten on 13.01.2017.
+ */
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, Input, Optional } from '@angular/core';
+import { take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "ngx-edu-sharing-api";
+/**
+ * Replaces the element's content with an icon.
+ *
+ * Example: `<i esIcon="save"></i>`
+ *
+ * Optionally, a translated `aria-label` can be attached by setting `aria` to a truthy value: `<i
+ * esIcon="save" aria="true"></i>`. Otherwise, `aria-hidden` will be set.
+ *
+ * For backwards compatibility, the directive is also activated on elements that set
+ * `class="material-icons"`. This is mainly to set the `aria-hidden` attribute. Occurrences should
+ * be updated to the syntax above.
+ */
+export class IconDirective {
+    /**
+     * An alt text to show to screen readers.
+     *
+     * If omitted, the icon will be invisible to screen readers.
+     *
+     * @see https://material.angular.io/components/icon/overview#indicator-icons
+     */
+    set altText(altText) {
+        this.setAltText(altText);
+    }
+    /** If true, an alt text (see above) will be set based on the icon. */
+    set aria(aria) {
+        aria = coerceBooleanProperty(aria);
+        if (aria !== this._aria) {
+            this._aria = aria;
+            if (this.isReady) {
+                this.updateAria();
+            }
+        }
+    }
+    set esIcon(id) {
+        this.setIcon(id);
+    }
+    constructor(element, translate, config) {
+        this.element = element;
+        this.translate = translate;
+        this.config = config;
+        this.isReady = false;
+    }
+    async ngOnInit() {
+        this.isReady = true;
+        this.element.nativeElement.setAttribute('aria-hidden', 'true');
+        this.updateAria();
+        // FIXME: This might resolve after `setIcon` was called and mappings might be ignored.
+        await this.config.observeConfig().pipe(take(1)).toPromise();
+        this.iconsConfig = this.config.instant('icons', null);
+    }
+    ngOnDestroy() {
+        if (this.altTextSpan) {
+            this.altTextSpan.remove();
+        }
+    }
+    setIcon(id) {
+        if (this._id) {
+            this.element.nativeElement.classList.remove('edu-icons', 'custom-icons', 'material-icons');
+        }
+        let customClass = null;
+        const mapping = this.iconsConfig?.filter((i) => i.original === id);
+        if (mapping?.length === 1) {
+            id = mapping[0].replace || '';
+            customClass = mapping[0].cssClass;
+        }
+        this._id = id;
+        if (this._aria) {
+            this.updateAria();
+        }
+        let cssClass;
+        if (id?.startsWith('edu-') && !customClass) {
+            cssClass = 'edu-icons';
+            id = id.substr(4);
+        }
+        else if (id?.startsWith('custom-') || customClass) {
+            cssClass = 'custom-icons';
+            id = id.substr(7);
+        }
+        else {
+            cssClass = 'material-icons';
+        }
+        this.element.nativeElement.classList.add(cssClass);
+        if (customClass) {
+            this.element.nativeElement.classList.add(customClass);
+        }
+        this.element.nativeElement.innerText = id;
+    }
+    updateAria() {
+        if (this._aria !== undefined) {
+            if (this._aria && this._id) {
+                this.translate.get('ICON_LABELS.' + this._id).subscribe((lang) => {
+                    this.setAltText(lang);
+                });
+            }
+            else {
+                this.setAltText(null);
+            }
+        }
+    }
+    setAltText(altText) {
+        if (altText && !this.altTextSpan) {
+            this.insertAltTextSpan();
+        }
+        if (this.altTextSpan) {
+            this.altTextSpan.innerText = altText;
+        }
+    }
+    insertAltTextSpan() {
+        this.altTextSpan = document.createElement('span');
+        this.altTextSpan.classList.add('cdk-visually-hidden');
+        this.element.nativeElement.insertAdjacentElement('afterend', this.altTextSpan);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: IconDirective, deps: [{ token: i0.ElementRef }, { token: i1.TranslateService }, { token: i2.ConfigService, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.6", type: IconDirective, selector: "i[esIcon], i.material-icons", inputs: { altText: "altText", aria: "aria", esIcon: "esIcon" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: IconDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'i[esIcon], i.material-icons',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.TranslateService }, { type: i2.ConfigService, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { altText: [{
+                type: Input
+            }], aria: [{
+                type: Input
+            }], esIcon: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"icon.directive.js","sourceRoot":"","sources":["../../../../../projects/edu-sharing-ui/src/lib/directives/icon.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Created by Torsten on 13.01.2017.\n */\n\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Directive, ElementRef, Input, OnInit, OnDestroy, Optional } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { ConfigService } from 'ngx-edu-sharing-api';\nimport { take } from 'rxjs/operators';\n\n/**\n * Replaces the element's content with an icon.\n *\n * Example: `<i esIcon=\"save\"></i>`\n *\n * Optionally, a translated `aria-label` can be attached by setting `aria` to a truthy value: `<i\n * esIcon=\"save\" aria=\"true\"></i>`. Otherwise, `aria-hidden` will be set.\n *\n * For backwards compatibility, the directive is also activated on elements that set\n * `class=\"material-icons\"`. This is mainly to set the `aria-hidden` attribute. Occurrences should\n * be updated to the syntax above.\n */\n@Directive({\n    selector: 'i[esIcon], i.material-icons',\n})\nexport class IconDirective implements OnInit, OnDestroy {\n    private _id: string;\n    private _aria: boolean;\n    private iconsConfig: Array<{ original: string; replace?: string; cssClass?: string }>;\n    private altTextSpan: HTMLElement;\n    private isReady = false;\n\n    /**\n     * An alt text to show to screen readers.\n     *\n     * If omitted, the icon will be invisible to screen readers.\n     *\n     * @see https://material.angular.io/components/icon/overview#indicator-icons\n     */\n    @Input() set altText(altText: string) {\n        this.setAltText(altText);\n    }\n\n    /** If true, an alt text (see above) will be set based on the icon. */\n    @Input() set aria(aria: boolean) {\n        aria = coerceBooleanProperty(aria);\n        if (aria !== this._aria) {\n            this._aria = aria;\n            if (this.isReady) {\n                this.updateAria();\n            }\n        }\n    }\n\n    @Input() set esIcon(id: string) {\n        this.setIcon(id);\n    }\n\n    constructor(\n        private element: ElementRef<HTMLElement>,\n        private translate: TranslateService,\n        @Optional() private config: ConfigService,\n    ) {}\n\n    async ngOnInit() {\n        this.isReady = true;\n        this.element.nativeElement.setAttribute('aria-hidden', 'true');\n        this.updateAria();\n\n        // FIXME: This might resolve after `setIcon` was called and mappings might be ignored.\n        await this.config.observeConfig().pipe(take(1)).toPromise();\n        this.iconsConfig = this.config.instant('icons', null);\n    }\n\n    ngOnDestroy(): void {\n        if (this.altTextSpan) {\n            this.altTextSpan.remove();\n        }\n    }\n\n    private setIcon(id: string) {\n        if (this._id) {\n            this.element.nativeElement.classList.remove(\n                'edu-icons',\n                'custom-icons',\n                'material-icons',\n            );\n        }\n        let customClass: string = null;\n        const mapping = this.iconsConfig?.filter((i) => i.original === id);\n        if (mapping?.length === 1) {\n            id = mapping[0].replace || '';\n            customClass = mapping[0].cssClass;\n        }\n        this._id = id;\n        if (this._aria) {\n            this.updateAria();\n        }\n        let cssClass: string;\n        if (id?.startsWith('edu-') && !customClass) {\n            cssClass = 'edu-icons';\n            id = id.substr(4);\n        } else if (id?.startsWith('custom-') || customClass) {\n            cssClass = 'custom-icons';\n            id = id.substr(7);\n        } else {\n            cssClass = 'material-icons';\n        }\n        this.element.nativeElement.classList.add(cssClass);\n        if (customClass) {\n            this.element.nativeElement.classList.add(customClass);\n        }\n        this.element.nativeElement.innerText = id;\n    }\n\n    private updateAria() {\n        if (this._aria !== undefined) {\n            if (this._aria && this._id) {\n                this.translate.get('ICON_LABELS.' + this._id).subscribe((lang) => {\n                    this.setAltText(lang);\n                });\n            } else {\n                this.setAltText(null);\n            }\n        }\n    }\n\n    private setAltText(altText: string): void {\n        if (altText && !this.altTextSpan) {\n            this.insertAltTextSpan();\n        }\n        if (this.altTextSpan) {\n            this.altTextSpan.innerText = altText;\n        }\n    }\n\n    private insertAltTextSpan(): void {\n        this.altTextSpan = document.createElement('span');\n        this.altTextSpan.classList.add('cdk-visually-hidden');\n        this.element.nativeElement.insertAdjacentElement('afterend', this.altTextSpan);\n    }\n}\n"]}

package/esm2022/lib/dropdown/dropdown.component.mjs

@@ -0,0 +1,70 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { Helper } from '../util/helper';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/ui.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/menu";
+import * as i4 from "@angular/material/tooltip";
+import * as i5 from "../directives/icon.directive";
+import * as i6 from "@ngx-translate/core";
+import * as i7 from "../pipes/replace-chars.pipe";
+import * as i8 from "../pipes/option-tooltip.pipe";
+/**
+ * The dropdown is one base component of the action bar (showing more actions),
+ * but can also be used standalone.
+ */
+export class DropdownComponent {
+    set options(options) {
+        this._options = this.ui.filterValidOptions(Helper.deepCopyArray(options));
+    }
+    constructor(ui) {
+        this.ui = ui;
+        this.position = 'left';
+        /**
+         * Should disabled ("greyed out") options be shown or hidden?
+         */
+        this.showDisabled = true;
+    }
+    click(option) {
+        if (!option.isEnabled) {
+            return;
+        }
+        setTimeout(() => option.callback(this.callbackObject));
+    }
+    isNewGroup(i) {
+        if (i > 0) {
+            return this._options[i].group !== this._options[i - 1].group;
+        }
+        return false;
+    }
+    /** Whether there are any enabled options so we can open the menu. */
+    canShowDropdown() {
+        // We can only open the dropdown menu, when there is at least one enabled option. Even when
+        // there are options with `showDisabled: true`, showing a menu with no selectable option
+        // causes a11y issues.
+        return this._options?.some((o) => o.isEnabled);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: DropdownComponent, deps: [{ token: i1.UIService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.6", type: DropdownComponent, selector: "es-dropdown", inputs: { position: "position", options: "options", callbackObject: "callbackObject", showDisabled: "showDisabled", menuClass: "menuClass" }, viewQueries: [{ propertyName: "menu", first: true, predicate: ["dropdown"], descendants: true, static: true }, { propertyName: "menuTrigger", first: true, predicate: ["menuTrigger"], descendants: true }], ngImport: i0, template: "<mat-menu\n  #dropdown=\"matMenu\"\n  class=\"mat-dropdown-menu\"\n  [class]=\"menuClass\"\n  backdropClass=\"mat-dropdown-menu\"\n  [xPosition]=\"position === 'right' ? 'after' : 'before'\"\n>\n  <!-- MatMenu has role=\"menu\", so the only meaningful role of descendants is \"menuitem\" -->\n  <ul role=\"none\">\n    <ng-container *ngFor=\"let option of _options; let i = index\">\n      <li *ngIf=\"option.isEnabled || showDisabled\" role=\"none\">\n        <button\n          mat-menu-item\n          class=\"mat-menu-item collection-item-{{\n            option.name | replaceChars : { search: '.', replace: '-' }\n          }}\"\n          matTooltip=\"{{ option | optionTooltip }}\"\n          matTooltipPosition=\"right\"\n          matTooltipTouchGestures=\"off\"\n          [class.mat-menu-item-separate]=\"option.isSeparate || isNewGroup(i)\"\n          [class.mat-menu-item-selected]=\"option.isSelected\"\n          [disabled]=\"!option.isEnabled\"\n          (click)=\"click(option)\"\n          attr.data-test=\"menu-item-{{ option.name }}\"\n        >\n          <i [esIcon]=\"option.icon\"></i> {{ option.name | translate }}\n        </button>\n      </li>\n    </ng-container>\n  </ul>\n</mat-menu>\n<div #menuTrigger=\"matMenuTrigger\" [matMenuTriggerFor]=\"menu\" class=\"display-none\"></div>\n", styles: ["::ng-deep .mat-dropdown-menu .mat-mdc-menu-content{min-width:200px}::ng-deep .mat-dropdown-menu .mat-mdc-menu-content>ul>li>button{display:flex;align-items:center}::ng-deep .mat-dropdown-menu .mat-mdc-menu-content>ul>li>button:not(:disabled)>span{color:var(--primary)}::ng-deep .mat-dropdown-menu .mat-mdc-menu-content>ul>li>button>i{width:35px}::ng-deep .mat-dropdown-menu .mat-mdc-menu-content:not(:empty){padding:0!important}::ng-deep .mat-dropdown-menu ul{margin:0;list-style:none;padding-left:0}::ng-deep .mat-dropdown-menu ul li .mat-mdc-menu-item .mat-mdc-menu-item-text{display:flex;align-items:center}::ng-deep .mat-dropdown-menu ul li .mat-mdc-menu-item .mat-mdc-menu-item-text i{margin-right:10px}::ng-deep .mat-dropdown-menu ul li .mat-mdc-menu-item:hover:not([disabled]),::ng-deep .mat-dropdown-menu ul li .mat-mdc-menu-item.cdk-focused{color:var(--itemSelectedTextColor);background-color:var(--listItemSelectedBackground)}::ng-deep .mat-dropdown-menu ul li .mat-mdc-menu-item.cdk-keyboard-focused{outline:none;border:var(--focusWidth) solid var(--palette-primary-300)}::ng-deep .mat-dropdown-menu ul li .mat-menu-item-separate{border-top:1px solid #ccc}@media screen and (max-width: calc(var(--mobileWidth) - var(--mobileStage) * 1)){::ng-deep .mat-dropdown-menu ul li.cdk-overlay-backdrop{background:rgba(0,0,0,.8)}::ng-deep .mat-dropdown-menu ul li.mat-menu-panel{position:fixed;bottom:0;left:0;max-width:100%;width:100%;border-radius:0}}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.MatMenu, selector: "mat-menu", exportAs: ["matMenu"] }, { kind: "component", type: i3.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i3.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", exportAs: ["matMenuTrigger"] }, { kind: "directive", type: i4.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { kind: "directive", type: i5.IconDirective, selector: "i[esIcon], i.material-icons", inputs: ["altText", "aria", "esIcon"] }, { kind: "pipe", type: i6.TranslatePipe, name: "translate" }, { kind: "pipe", type: i7.ReplaceCharsPipe, name: "replaceChars" }, { kind: "pipe", type: i8.OptionTooltipPipe, name: "optionTooltip" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: DropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'es-dropdown', template: "<mat-menu\n  #dropdown=\"matMenu\"\n  class=\"mat-dropdown-menu\"\n  [class]=\"menuClass\"\n  backdropClass=\"mat-dropdown-menu\"\n  [xPosition]=\"position === 'right' ? 'after' : 'before'\"\n>\n  <!-- MatMenu has role=\"menu\", so the only meaningful role of descendants is \"menuitem\" -->\n  <ul role=\"none\">\n    <ng-container *ngFor=\"let option of _options; let i = index\">\n      <li *ngIf=\"option.isEnabled || showDisabled\" role=\"none\">\n        <button\n          mat-menu-item\n          class=\"mat-menu-item collection-item-{{\n            option.name | replaceChars : { search: '.', replace: '-' }\n          }}\"\n          matTooltip=\"{{ option | optionTooltip }}\"\n          matTooltipPosition=\"right\"\n          matTooltipTouchGestures=\"off\"\n          [class.mat-menu-item-separate]=\"option.isSeparate || isNewGroup(i)\"\n          [class.mat-menu-item-selected]=\"option.isSelected\"\n          [disabled]=\"!option.isEnabled\"\n          (click)=\"click(option)\"\n          attr.data-test=\"menu-item-{{ option.name }}\"\n        >\n          <i [esIcon]=\"option.icon\"></i> {{ option.name | translate }}\n        </button>\n      </li>\n    </ng-container>\n  </ul>\n</mat-menu>\n<div #menuTrigger=\"matMenuTrigger\" [matMenuTriggerFor]=\"menu\" class=\"display-none\"></div>\n", styles: ["::ng-deep .mat-dropdown-menu .mat-mdc-menu-content{min-width:200px}::ng-deep .mat-dropdown-menu .mat-mdc-menu-content>ul>li>button{display:flex;align-items:center}::ng-deep .mat-dropdown-menu .mat-mdc-menu-content>ul>li>button:not(:disabled)>span{color:var(--primary)}::ng-deep .mat-dropdown-menu .mat-mdc-menu-content>ul>li>button>i{width:35px}::ng-deep .mat-dropdown-menu .mat-mdc-menu-content:not(:empty){padding:0!important}::ng-deep .mat-dropdown-menu ul{margin:0;list-style:none;padding-left:0}::ng-deep .mat-dropdown-menu ul li .mat-mdc-menu-item .mat-mdc-menu-item-text{display:flex;align-items:center}::ng-deep .mat-dropdown-menu ul li .mat-mdc-menu-item .mat-mdc-menu-item-text i{margin-right:10px}::ng-deep .mat-dropdown-menu ul li .mat-mdc-menu-item:hover:not([disabled]),::ng-deep .mat-dropdown-menu ul li .mat-mdc-menu-item.cdk-focused{color:var(--itemSelectedTextColor);background-color:var(--listItemSelectedBackground)}::ng-deep .mat-dropdown-menu ul li .mat-mdc-menu-item.cdk-keyboard-focused{outline:none;border:var(--focusWidth) solid var(--palette-primary-300)}::ng-deep .mat-dropdown-menu ul li .mat-menu-item-separate{border-top:1px solid #ccc}@media screen and (max-width: calc(var(--mobileWidth) - var(--mobileStage) * 1)){::ng-deep .mat-dropdown-menu ul li.cdk-overlay-backdrop{background:rgba(0,0,0,.8)}::ng-deep .mat-dropdown-menu ul li.mat-menu-panel{position:fixed;bottom:0;left:0;max-width:100%;width:100%;border-radius:0}}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.UIService }]; }, propDecorators: { menu: [{
+                type: ViewChild,
+                args: ['dropdown', { static: true }]
+            }], menuTrigger: [{
+                type: ViewChild,
+                args: ['menuTrigger']
+            }], position: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], callbackObject: [{
+                type: Input
+            }], showDisabled: [{
+                type: Input
+            }], menuClass: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/edu-sharing-ui-configuration.mjs

@@ -0,0 +1,41 @@
+import { Injectable, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export const EDU_SHARING_UI_CONFIG = new InjectionToken('EDU_SHARING_API_CONFIG');
+export class EduSharingUiConfiguration {
+    static create(params = {}) {
+        return { ...new EduSharingUiConfiguration(), ...params };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: EduSharingUiConfiguration, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: EduSharingUiConfiguration, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: EduSharingUiConfiguration, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+export function getConfigProvider(params) {
+    return [
+        // Provide the params given to `forRoot()`. These can be overridden by the application by
+        // providing `EDU_SHARING_API_CONFIG` itself.
+        {
+            provide: EDU_SHARING_UI_CONFIG,
+            useValue: params,
+        },
+        // Inject `configuration` as both, `ApiConfiguration` and `EduSharingApiConfiguration`, to pass
+        // `rootUrl` on to `ApiModule` while also adding our custom configuration.
+        {
+            provide: EduSharingUiConfiguration,
+            deps: [EDU_SHARING_UI_CONFIG],
+            // deps: [[new Optional(), EDU_SHARING_API_CONFIG]],
+            useFactory: (configParams) => EduSharingUiConfiguration.create(configParams),
+        },
+        {
+            provide: EduSharingUiConfiguration,
+            deps: [EDU_SHARING_UI_CONFIG],
+            // deps: [[new Optional(), EDU_SHARING_API_CONFIG]],
+            useFactory: (configParams) => EduSharingUiConfiguration.create(configParams),
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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