ngx-edu-sharing-ui 0.7.0 → 9.0.1

package/lib/list-items/node-source.pipe.d.ts

@@ -0,0 +1,16 @@
+import { PipeTransform } from '@angular/core';
+import { NetworkService } from 'ngx-edu-sharing-api';
+import { NodeHelperService } from '../services/node-helper.service';
+import * as i0 from "@angular/core";
+export declare class NodeSourcePipe implements PipeTransform {
+    private nodeHelper;
+    private networkApi;
+    private homeRepository;
+    constructor(nodeHelper: NodeHelperService, networkApi: NetworkService);
+    transform(replicationSource: string, args: {
+        mode: 'text' | 'url' | 'escaped';
+    }): string;
+    private escape;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeSourcePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NodeSourcePipe, "appNodeSource", false>;
+}

package/lib/node-entries/combined-data-source.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { NodeDataSource } from './node-data-source';
+import { Node, GenericAuthority } from 'ngx-edu-sharing-api';
+/**
+ * data source which joins multiple underlying data sources
+ * used for the "all" search
+ */
+export declare class CombinedDataSource<T extends Node | GenericAuthority> extends NodeDataSource<T> {
+    private dataSources;
+    constructor(dataSources: NodeDataSource<T>[]);
+    connect(): Observable<T[]>;
+    disconnect(): void;
+    hasMore(): boolean;
+    getData(): any;
+    isEmpty(): boolean;
+    getTotal(): number;
+    isFullyLoaded(): boolean;
+    getDatasource(position: number): NodeDataSource<T>;
+}

package/{src/lib/node-entries/custom-templates-data-source.ts → lib/node-entries/custom-templates-data-source.d.ts}

@@ -1,6 +1,6 @@
 import { NodeDataSource } from './node-data-source';
-
 /**
  * this is a special data source to provide custom card layouts into the node-entries components
  */
-export class CustomTemplatesDataSource extends NodeDataSource<any> {}
+export declare class CustomTemplatesDataSource extends NodeDataSource<any> {
+}

package/lib/node-entries/drag-preview/drag-preview.component.d.ts

@@ -0,0 +1,11 @@
+import { ListItem } from '../../types/list-item';
+import { Node } from 'ngx-edu-sharing-api';
+import { NodeEntriesDataType } from '../entries-model';
+import * as i0 from "@angular/core";
+export declare class DragPreviewComponent<T extends NodeEntriesDataType> {
+    node: Node;
+    selected: T[];
+    item: ListItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragPreviewComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DragPreviewComponent<any>, "es-drag-preview", never, { "node": { "alias": "node"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "item": { "alias": "item"; "required": false; }; }, {}, never, never, false, never>;
+}

package/{src/lib/node-entries/entries-model.ts → lib/node-entries/entries-model.d.ts}

@@ -1,74 +1,55 @@
 import { Sort } from '@angular/material/sort';
-
 import { SelectionModel } from '@angular/cdk/collections';
 import { CustomOptions, OptionItem, Target } from '../types/option-item';
 import { ListItem, ListItemSort } from '../types/list-item';
 import { CanDrop, DragData, DropAction } from '../types/drag-drop';
 import { Node, GenericAuthority } from 'ngx-edu-sharing-api';
 import { ActionbarComponent } from '../actionbar/actionbar.component';
-
-export type NodeRoot =
-    | 'MY_FILES'
-    | 'SHARED_FILES'
-    | 'MY_SHARED_FILES'
-    | 'TO_ME_SHARED_FILES'
-    | 'WORKFLOW_RECEIVE'
-    | 'RECYCLE'
-    | 'ALL_FILES';
-
-export enum NodeEntriesDisplayType {
-    Table,
-    Grid,
-    SmallGrid,
+export type NodeRoot = 'MY_FILES' | 'SHARED_FILES' | 'MY_SHARED_FILES' | 'TO_ME_SHARED_FILES' | 'WORKFLOW_RECEIVE' | 'RECYCLE' | 'ALL_FILES';
+export declare enum NodeEntriesDisplayType {
+    Table = 0,
+    Grid = 1,
+    SmallGrid = 2
 }
-
-export enum InteractionType {
-    // create router link
-    DefaultActionLink,
-    // emit an event
-    Emitter,
-    None,
+export declare enum InteractionType {
+    DefaultActionLink = 0,
+    Emitter = 1,
+    None = 2
 }
-
-export type ListOptions = { [key in Target]?: OptionItem[] };
+export type ListOptions = {
+    [key in Target]?: OptionItem[];
+};
 export type ListOptionsConfig = {
     actionbar?: ActionbarComponent;
     parent?: Node;
     customOptions?: CustomOptions;
 };
-
 export interface ListSortConfig extends Sort {
     columns: ListItemSort[];
     allowed?: boolean;
     customSortingInProgress?: boolean;
 }
-
 export type DropTarget = Node | NodeRoot;
-
 export interface DropSource<T extends NodeEntriesDataType> {
     element: T[];
-    // sourceList: ListEventInterface<T>;
     mode: DropAction;
 }
-
 export interface ListDragGropConfig<T extends NodeEntriesDataType> {
     dragAllowed: boolean;
     dropAllowed?: (dragData: DragData<T>) => CanDrop;
     dropped?: (target: Node, source: DropSource<NodeEntriesDataType>) => void;
 }
-
-export enum ClickSource {
-    Preview,
-    Icon,
-    Metadata,
-    Comments,
-    Overlay,
+export declare enum ClickSource {
+    Preview = 0,
+    Icon = 1,
+    Metadata = 2,
+    Comments = 3,
+    Overlay = 4
 }
-
 export type NodeClickEvent<T extends NodeEntriesDataType> = {
     element: T;
     source: ClickSource;
-    attribute?: ListItem; // only when source === Metadata
+    attribute?: ListItem;
 };
 export type FetchEvent = {
     offset: number;
@@ -92,27 +73,18 @@ export type GridConfig = {
      */
     layout?: GridLayout;
 };
-
 export interface ListEventInterface<T extends NodeEntriesDataType> {
     updateNodes(nodes: void | T[]): void;
-
     getDisplayType(): NodeEntriesDisplayType;
-
     setDisplayType(displayType: NodeEntriesDisplayType): void;
-
     showReorderColumnsDialog(): void;
-
     addVirtualNodes(virtual: T[]): void;
-
     setOptions(options: ListOptions): void;
-
     /**
      * activate option (dropdown) generation
      */
     initOptionsGenerator(config: ListOptionsConfig): void | Promise<void>;
-
     getSelection(): SelectionModel<T>;
-
     /**
      * triggered when nodes/objects are deleted and should not be shown in the list anymore
      */

package/lib/node-entries/items-cap.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+export declare class ItemsCap<T> {
+    /** The number of items to which the data should be capped. */
+    get cap(): number | null;
+    set cap(value: number | null);
+    private _cap;
+    /** Whether to temporarily disable capping. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Whether there is more data available that is currently being capped. */
+    get isActivelyCapping(): boolean;
+    private _isActivelyCapping;
+    private _effectiveCap;
+    connect(dataStream: Observable<T[]>): Observable<T[]>;
+    private _needToCap;
+}

package/lib/node-entries/list-item-label.pipe.d.ts

@@ -0,0 +1,14 @@
+import { PipeTransform } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { ListItem } from '../types/list-item';
+import * as i0 from "@angular/core";
+export declare class ListItemLabelPipe implements PipeTransform {
+    private translate;
+    constructor(translate: TranslateService);
+    transform(item: ListItem, args?: {
+        fallback: string;
+    }): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemLabelPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ListItemLabelPipe, "esListItemLabel", false>;
+}

package/lib/node-entries/node-cache.d.ts

@@ -0,0 +1,17 @@
+export interface NodeCacheRange {
+    startIndex: number;
+    endIndex: number;
+}
+export interface NodeCacheSlice<T> extends NodeCacheRange {
+    data: readonly T[];
+}
+export declare class NodeCache<T> {
+    private _slices;
+    add(slice: NodeCacheSlice<T>): void;
+    clear(): void;
+    get(range: NodeCacheRange): T[] | null;
+    getMissingRange(requestedRange: NodeCacheRange): NodeCacheRange | null;
+    private _normalizeSlices;
+    private _canMerge;
+    private _merge;
+}

package/{src/lib/node-entries/node-data-source-remote.ts → lib/node-entries/node-data-source-remote.d.ts}

@@ -5,28 +5,18 @@ import { ActivatedRoute } from '@angular/router';
 import { PaginationStrategy } from './node-entries-global.service';
 import { Sort } from '@angular/material/sort';
 import { SortPanel } from '../types/list-item';
-
 export interface PaginationConfig {
     defaultPageSize: number;
     strategy: PaginationStrategy;
 }
-
-export abstract class NodeDataSourceRemote<
-    T extends Node | GenericAuthority = Node,
-    P extends MatTableDataSourcePaginator = MatTableDataSourcePaginator,
-> extends NodeDataSource<T> {
+export declare abstract class NodeDataSourceRemote<T extends Node | GenericAuthority = Node, P extends MatTableDataSourcePaginator = MatTableDataSourcePaginator> extends NodeDataSource<T> {
     abstract get paginator(): P | null;
     abstract set paginator(value: P | null);
     abstract get sortPanel(): SortPanel;
     abstract set sortPanel(value: SortPanel);
     abstract loadMore(): boolean;
-
     abstract registerQueryParameters(route: ActivatedRoute): void;
-
-    abstract init({
-        paginationConfig,
-        defaultSort,
-    }: {
+    abstract init({ paginationConfig, defaultSort, }: {
         paginationConfig: PaginationConfig;
         defaultSort: Sort;
     }): void;

package/lib/node-entries/node-data-source.d.ts

@@ -0,0 +1,42 @@
+import { DataSource } from '@angular/cdk/collections';
+import { BehaviorSubject, Observable, Subscription } from 'rxjs';
+import { ItemsCap } from './items-cap';
+import { Node, GenericAuthority, Pagination } from 'ngx-edu-sharing-api';
+export type LoadingState = 'initial' | 'reset' | 'page' | false;
+export declare class NodeDataSource<T extends Node | GenericAuthority> extends DataSource<T> {
+    protected dataStream: BehaviorSubject<T[]>;
+    private pagination$;
+    isLoadingSubject: BehaviorSubject<true | LoadingState>;
+    get isLoading(): LoadingState | boolean;
+    set isLoading(isLoading: LoadingState | boolean);
+    initialPageLoaded: boolean;
+    protected _itemsCap: ItemsCap<T> | null;
+    get itemsCap(): ItemsCap<T> | null;
+    set itemsCap(value: ItemsCap<T> | null);
+    protected renderData: BehaviorSubject<T[]>;
+    protected renderDataSubscription: Subscription | null;
+    constructor(initialData?: T[]);
+    connect(): Observable<T[]>;
+    private connectRenderData;
+    connectPagination(): Observable<Pagination>;
+    disconnect(): void;
+    setData(data: T[], pagination?: Pagination): void;
+    appendData(appendData: T[], location?: 'before' | 'after'): void;
+    /**
+     * Removes elements from the visible data.
+     */
+    removeData(toRemove: T[]): void;
+    setPagination(pagination: Pagination): void;
+    reset(): void;
+    hasMore(): boolean;
+    getData(): T[];
+    isEmpty(): boolean;
+    getTotal(): number;
+    isFullyLoaded(): boolean;
+    /**
+     * force a refresh of all elements in the current data stream
+     * trigger this to enforce a rebuild of the nodes in all sub-components
+     * i.e. if data from some nodes has changed
+     */
+    refresh(): void;
+}

package/lib/node-entries/node-entries-card/node-entries-card.component.d.ts

@@ -0,0 +1,45 @@
+import { ApplicationRef, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { ClickSource, InteractionType } from '../entries-model';
+import { NodeEntriesTemplatesService } from '../node-entries-templates.service';
+import { CustomFieldSpecialType, NodeEntriesGlobalService } from '../node-entries-global.service';
+import { Target } from '../../types/option-item';
+import { NodeEntriesService } from '../../services/node-entries.service';
+import { NodeHelperService } from '../../services/node-helper.service';
+import { AuthenticationService, ConfigService, Node } from 'ngx-edu-sharing-api';
+import { DropdownComponent } from '../../dropdown/dropdown.component';
+import { Toast } from '../../services/abstract/toast.service';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class NodeEntriesCardComponent<T extends Node> implements OnChanges, OnInit {
+    entriesService: NodeEntriesService<T>;
+    nodeHelper: NodeHelperService;
+    applicationRef: ApplicationRef;
+    configService: ConfigService;
+    authenticationService: AuthenticationService;
+    templatesService: NodeEntriesTemplatesService;
+    private nodeEntriesGlobalService;
+    private toast;
+    readonly InteractionType: typeof InteractionType;
+    readonly Target: typeof Target;
+    readonly ClickSource: typeof ClickSource;
+    readonly CustomFieldSpecialType: typeof CustomFieldSpecialType;
+    dropdown: DropdownComponent;
+    menuTrigger: MatMenuTrigger;
+    node: T;
+    dropdownLeft: number;
+    dropdownTop: number;
+    showRatings: BehaviorSubject<boolean>;
+    isCollection: boolean;
+    constructor(entriesService: NodeEntriesService<T>, nodeHelper: NodeHelperService, applicationRef: ApplicationRef, configService: ConfigService, authenticationService: AuthenticationService, templatesService: NodeEntriesTemplatesService, nodeEntriesGlobalService: NodeEntriesGlobalService, toast: Toast);
+    ngOnChanges(changes: SimpleChanges): void;
+    getTextColor(): "#000" | "#fff";
+    optionsOnCard(): import("../../types/option-item").OptionItem[];
+    openContextmenu(event: MouseEvent | Event): void;
+    getVisibleColumns(): import("ngx-edu-sharing-ui").ListItem[];
+    openMenu(node: T): Promise<void>;
+    ngOnInit(): Promise<void>;
+    getTemplate(name: CustomFieldSpecialType): import("@angular/core").TemplateRef<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeEntriesCardComponent<any>, [null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeEntriesCardComponent<any>, "es-node-entries-card", never, { "dropdown": { "alias": "dropdown"; "required": false; }; "node": { "alias": "node"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/node-entries/node-entries-card-grid/node-entries-card-grid.component.d.ts

@@ -0,0 +1,92 @@
+import { CdkDragEnter, CdkDropList } from '@angular/cdk/drag-drop';
+import { ElementRef, NgZone, OnDestroy, OnInit, QueryList, TemplateRef } from '@angular/core';
+import { Sort } from '@angular/material/sort';
+import { Node } from 'ngx-edu-sharing-api';
+import * as rxjs from 'rxjs';
+import { GridLayout, NodeEntriesDisplayType } from '../entries-model';
+import { ItemsCap } from '../items-cap';
+import { NodeEntriesGlobalService } from '../node-entries-global.service';
+import { NodeEntriesTemplatesService } from '../node-entries-templates.service';
+import { SortSelectPanelComponent } from '../sort-select-panel/sort-select-panel.component';
+import { Target } from '../../types/option-item';
+import { NodeEntriesService } from '../../services/node-entries.service';
+import { UIService } from '../../services/ui.service';
+import { ListItemSort } from '../../types/list-item';
+import { DragData } from '../../types/drag-drop';
+import * as i0 from "@angular/core";
+export declare class NodeEntriesCardGridComponent<T extends Node> implements OnInit, OnDestroy {
+    entriesService: NodeEntriesService<T>;
+    entriesGlobalService: NodeEntriesGlobalService;
+    templatesService: NodeEntriesTemplatesService;
+    ui: UIService;
+    private ngZone;
+    readonly NodeEntriesDisplayType: typeof NodeEntriesDisplayType;
+    readonly Target: typeof Target;
+    /**
+     * relative scrolling when a scrolling arrow (left or right) is used
+     * a value of 1 would mean to scroll the full width of the entire content
+     */
+    readonly ScrollingOffsetPercentage = 0.4;
+    set gridTop(value: TemplateRef<unknown>);
+    set sortPanel(value: SortSelectPanelComponent);
+    dropListsQuery: QueryList<CdkDropList>;
+    gridRef: ElementRef;
+    itemRefs: QueryList<ElementRef<HTMLElement>>;
+    displayType: NodeEntriesDisplayType;
+    isDragging: boolean;
+    dropLists: CdkDropList[];
+    /**
+     * Whether the number of shown items is limited by `gridConfig.maxRows`.
+     *
+     * A value of `true` does not mean, that there would be more items available.
+     */
+    visibleItemsLimited: boolean;
+    layout: GridLayout;
+    /**
+     * updates via boxObserver
+     * and holds the information if scrolling in the direction is currently feasible
+     */
+    scroll: {
+        left: boolean;
+        right: boolean;
+    };
+    readonly nodes$: rxjs.Observable<T[]>;
+    private readonly maxRows$;
+    private readonly layout$;
+    private readonly itemsPerRowSubject;
+    readonly itemsCap: ItemsCap<T>;
+    private globalCursorStyle;
+    private destroyed;
+    constructor(entriesService: NodeEntriesService<T>, entriesGlobalService: NodeEntriesGlobalService, templatesService: NodeEntriesTemplatesService, ui: UIService, ngZone: NgZone);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private registerGridTop;
+    private registerItemsCap;
+    private registerLayout;
+    onSortChange(sort: Sort): void;
+    loadData(source: 'scroll' | 'button'): void;
+    onCustomSortingInProgressChange(): void;
+    onRearrangeDragEntered($event: CdkDragEnter): void;
+    onRearrangeDragStarted(): void;
+    onRearrangeDragEnded(): void;
+    getDragStartDelay(): number;
+    private registerVisibleItemsLimited;
+    private refreshDropLists;
+    private focusFirstNewItemWhenLoaded;
+    private focusOnce;
+    onGridSizeChanges(): void;
+    private getItemsPerRow;
+    getSortColumns(): ListItemSort[];
+    canDropNodes: (dragData: DragData<T>) => import("../../types/drag-drop").CanDrop;
+    onNodesDropped(dragData: DragData<Node>): void;
+    getDragEnabled(): boolean;
+    getDragData(node: T): T[];
+    onDragStarted(node: T): void;
+    onDragEnded(): void;
+    private canScroll;
+    updateScrollState(): void;
+    doScroll(direction: 'left' | 'right'): void;
+    isCustomTemplate(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeEntriesCardGridComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeEntriesCardGridComponent<any>, "es-node-entries-card-grid", never, { "displayType": { "alias": "displayType"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/node-entries/node-entries-card-small/node-entries-card-small.component.d.ts

@@ -0,0 +1,23 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { Target } from '../../types/option-item';
+import { ClickSource, InteractionType } from '../entries-model';
+import { NodeEntriesTemplatesService } from '../node-entries-templates.service';
+import { NodeEntriesService } from '../../services/node-entries.service';
+import { NodeHelperService } from '../../services/node-helper.service';
+import { Node } from 'ngx-edu-sharing-api';
+import * as i0 from "@angular/core";
+export declare class NodeEntriesCardSmallComponent<T extends Node> implements OnChanges {
+    entriesService: NodeEntriesService<T>;
+    nodeHelper: NodeHelperService;
+    templatesService: NodeEntriesTemplatesService;
+    readonly ClickSource: typeof ClickSource;
+    readonly InteractionType: typeof InteractionType;
+    readonly Target: typeof Target;
+    node: T;
+    constructor(entriesService: NodeEntriesService<T>, nodeHelper: NodeHelperService, templatesService: NodeEntriesTemplatesService);
+    ngOnChanges(changes: SimpleChanges): void;
+    optionsOnCard(): import("../../types/option-item").OptionItem[];
+    openContextmenu(event: MouseEvent | Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeEntriesCardSmallComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeEntriesCardSmallComponent<any>, "es-node-entries-card-small", never, { "node": { "alias": "node"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/node-entries/node-entries-global-options/node-entries-global-options.component.d.ts

@@ -0,0 +1,12 @@
+import { Node } from 'ngx-edu-sharing-api';
+import { NodeEntriesDisplayType } from '../entries-model';
+import { NodeEntriesService } from '../../services/node-entries.service';
+import * as i0 from "@angular/core";
+export declare class NodeEntriesGlobalOptionsComponent<T extends Node> {
+    entriesService: NodeEntriesService<T>;
+    readonly NodeEntriesDisplayType: typeof NodeEntriesDisplayType;
+    displayType: NodeEntriesDisplayType;
+    constructor(entriesService: NodeEntriesService<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeEntriesGlobalOptionsComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeEntriesGlobalOptionsComponent<any>, "es-node-entries-global-options", never, { "displayType": { "alias": "displayType"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/node-entries/node-entries-global.service.d.ts

@@ -0,0 +1,50 @@
+import { TemplateRef } from '@angular/core';
+import { Node } from 'ngx-edu-sharing-api';
+import { ListItemType } from '../types/list-item';
+import { Scope } from '../types/option-item';
+import * as i0 from "@angular/core";
+export type CustomField = {
+    type: ListItemType;
+    name: string | CustomFieldSpecialType;
+};
+export declare enum CustomFieldSpecialType {
+    preview = 0,
+    type = 1
+}
+export type CustomFieldInfo = {
+    type: ListItemType;
+    /**
+     * Either the property name (i.e. "cm:name") or a special value.
+     */
+    name: string | CustomFieldSpecialType;
+    /**
+     * Custom callback which should return true if the template should be used for the given item.
+     */
+    useCallback?: (node: Node) => boolean;
+    templateRef: TemplateRef<unknown>;
+};
+export type PaginationStrategy = 'infinite-scroll' | 'paginator';
+type PaginationScope = Scope | 'DEFAULT';
+/**
+ * this service is intended to add custom behaviour to the global tables & grid views
+ */
+export declare class NodeEntriesGlobalService {
+    private customFields;
+    private paginationStrategy;
+    private paginatorSizeOptions;
+    constructor();
+    setPaginationStrategy(scope: PaginationScope, strategy: PaginationStrategy): void;
+    getPaginationStrategy(scope: Scope): PaginationStrategy;
+    setPaginatorSizeOptions(scope: PaginationScope, size: number[]): void;
+    getPaginatorSizeOptions(scope: Scope): number[];
+    getCustomFieldTemplate(item: CustomField, node: Node): TemplateRef<unknown>;
+    /**
+     * Registers a custom (node) attribute you want to render via the given template.
+     *
+     * You may also override existing attributes if you want to provide a custom view.
+     */
+    registerCustomFieldRendering(customFieldInfo: CustomFieldInfo): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeEntriesGlobalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NodeEntriesGlobalService>;
+}
+export {};

package/lib/node-entries/node-entries-table/column-chooser/column-chooser.component.d.ts

@@ -0,0 +1,17 @@
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { EventEmitter } from '@angular/core';
+import { CdkOverlayOrigin } from '@angular/cdk/overlay';
+import { ListItem } from '../../../types/list-item';
+import * as i0 from "@angular/core";
+export declare class ColumnChooserComponent {
+    origin: CdkOverlayOrigin;
+    columnChooserVisible: boolean;
+    columnChooserVisibleChange: EventEmitter<boolean>;
+    columns: ListItem[];
+    columnsChange: EventEmitter<ListItem[]>;
+    constructor();
+    columnChooserDrop(event: CdkDragDrop<string[]>): void;
+    columnChooserToggle(columnIndex: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnChooserComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnChooserComponent, "es-column-chooser", never, { "origin": { "alias": "origin"; "required": false; }; "columnChooserVisible": { "alias": "columnChooserVisible"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; }, { "columnChooserVisibleChange": "columnChooserVisibleChange"; "columnsChange": "columnsChange"; }, never, never, false, never>;
+}

package/lib/node-entries/node-entries-table/node-entries-table.component.d.ts

@@ -0,0 +1,76 @@
+import { CdkOverlayOrigin } from '@angular/cdk/overlay';
+import { AfterViewInit, ApplicationRef, ChangeDetectorRef, ElementRef, NgZone, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort } from '@angular/material/sort';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { ClickSource, InteractionType, NodeEntriesDataType, NodeEntriesDisplayType } from '../entries-model';
+import { NodeEntriesGlobalService } from '../node-entries-global.service';
+import { NodeEntriesService } from '../../services/node-entries.service';
+import { UIService } from '../../services/ui.service';
+import { ListItem } from '../../types/list-item';
+import { CanDrop, DragData } from '../../types/drag-drop';
+import { Node } from 'ngx-edu-sharing-api';
+import { Target } from '../../types/option-item';
+import { Toast } from '../../services/abstract/toast.service';
+import { DropdownComponent } from '../../dropdown/dropdown.component';
+import * as i0 from "@angular/core";
+export declare class NodeEntriesTableComponent<T extends NodeEntriesDataType> implements OnChanges, AfterViewInit, OnDestroy {
+    entriesService: NodeEntriesService<T>;
+    entriesGlobalService: NodeEntriesGlobalService;
+    private applicationRef;
+    private toast;
+    private changeDetectorRef;
+    ui: UIService;
+    private ngZone;
+    private elementRef;
+    readonly InteractionType: typeof InteractionType;
+    readonly ClickSource: typeof ClickSource;
+    readonly NodeEntriesDisplayType: typeof NodeEntriesDisplayType;
+    readonly Target: typeof Target;
+    sort: MatSort;
+    paginator: MatPaginator;
+    columnChooserTrigger: CdkOverlayOrigin;
+    dropdown: DropdownComponent;
+    menuTrigger: MatMenuTrigger;
+    dropdownLeft: number;
+    dropdownTop: number;
+    loading: Observable<boolean>;
+    isPageSelected: rxjs.BehaviorSubject<boolean>;
+    isAllSelected: rxjs.BehaviorSubject<boolean>;
+    columnChooserVisible: boolean;
+    columnChooserTriggerReady: boolean;
+    error: Observable<any>;
+    pageSizeOptions: number[];
+    isDragging: boolean;
+    private readonly maximumColumnsNumber$;
+    readonly visibleDataColumns$: rxjs.Observable<ListItem[]>;
+    readonly visibleColumnNames$: rxjs.Observable<string[]>;
+    private destroyed;
+    constructor(entriesService: NodeEntriesService<T>, entriesGlobalService: NodeEntriesGlobalService, applicationRef: ApplicationRef, toast: Toast, changeDetectorRef: ChangeDetectorRef, ui: UIService, ngZone: NgZone, elementRef: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onRowContextMenu({ event, node }: {
+        event: MouseEvent | Event;
+        node: T;
+    }): void;
+    private updateSort;
+    private registerMaximumColumnsNumber;
+    private getMaximumColumnsNumber;
+    private getVisibleDataColumns;
+    private getVisibleColumnNames;
+    isSortable(column: ListItem): boolean;
+    toggleAll(checked: boolean): void;
+    private registerSortChanges;
+    canDrop: (dragData: DragData<T>) => CanDrop;
+    drop(dragData: DragData<Node>): void;
+    getDragData(node: T): T[];
+    onDragStarted(node: T): void;
+    onDragEnded(): void;
+    loadData(source: 'scroll' | 'button'): void;
+    openMenu(node: T): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeEntriesTableComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeEntriesTableComponent<any>, "es-node-entries-table", never, {}, {}, never, never, false, never>;
+}