@igo2/common 19.0.2 → 20.0.0-next.1

package/drag-drop/index.d.ts

@@ -1,5 +1,126 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, AfterContentInit, OnDestroy, QueryList, ModuleWithProviders } from '@angular/core';
+import { SelectionModel } from '@angular/cdk/collections';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { MatTreeNode } from '@angular/material/tree';
+
+declare class DragAndDropDirective {
+    allowedExtensions: string[];
+    protected filesDropped: EventEmitter<File[]>;
+    protected filesInvalid: EventEmitter<File[]>;
+    private background;
+    onDragOver(evt: any): void;
+    onDragLeave(evt: any): void;
+    onDrop(evt: any): void;
+    private validExtensions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragAndDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragAndDropDirective, "[igoDragAndDrop]", never, { "allowedExtensions": { "alias": "allowedExtensions"; "required": false; }; }, { "filesDropped": "filesDropped"; "filesInvalid": "filesInvalid"; }, never, never, true, never>;
+}
+
+interface TreeFlatNode<T = any> {
+    id: string;
+    isGroup: boolean;
+    disabled: boolean;
+    level: number;
+    descendantLevels?: number;
+    data: T;
+}
+interface DropPosition {
+    x: number;
+    y: number;
+    level: number;
+    type: DropPositionType;
+}
+type DropPositionType = 'above' | 'below' | 'inside';
+
+interface TreeDropEvent<T = any> {
+    node: TreeFlatNode<T>;
+    ref: TreeFlatNode<T>;
+    position: DropPositionType;
+}
+interface DragNodeListeners {
+    element: HTMLElement;
+    listeners: [string, EventListenerOrEventListenerObject][];
+}
+interface DropPermission {
+    canDrop: boolean;
+    message?: string;
+    params?: Record<string, unknown>;
+}
 /**
- * Generated bundle index. Do not edit.
+ * This directive should be use with a MatTree flatened
+ * It should add all logic to drag the MatTreeNode and connect the (onDrop) output
+ * Class added:
+ *    Tree: --dragging
+ *    Node: --drag-hover | --dragged
  */
-/// <amd-module name="@igo2/common/drag-drop" />
-export * from './public_api';
+declare class TreeDragDropDirective implements AfterContentInit, OnDestroy {
+    private elementRef;
+    private renderer;
+    draggedNode: TreeFlatNode;
+    dropNodeTarget: TreeFlatNode;
+    expandTimeout: number;
+    nodesListeners: DragNodeListeners[] | undefined;
+    dropLineTarget: HTMLElement;
+    highlightedNode: SelectionModel<TreeFlatNode<any>>;
+    treeControl: FlatTreeControl<TreeFlatNode>;
+    /** The default is 5 */
+    maxLevel: number;
+    set treeDragDropIsDisabled(disabled: boolean);
+    private isDisabled;
+    dragStart: EventEmitter<TreeFlatNode<any>>;
+    onDrop: EventEmitter<TreeDropEvent<any>>;
+    onDropError: EventEmitter<DropPermission>;
+    hostDragOver(event: Event): void;
+    hostDrop(event: DragEvent): void;
+    dragging: boolean;
+    nodes: QueryList<MatTreeNode<TreeFlatNode>>;
+    constructor();
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    onDragStart(node: TreeFlatNode): void;
+    dragEnd(): void;
+    dragOver(node: TreeFlatNode, event: DragEvent): void;
+    dragLeave(): void;
+    drop(event: DragEvent): void;
+    private addNodeClass;
+    private removeNodeClass;
+    private addAllListener;
+    private addListener;
+    private removeAllListener;
+    private setHighlightedNode;
+    private addDropTargetLine;
+    private removeDropTargetLine;
+    private updateDropTargetLinePosition;
+    private handleGroupExpansion;
+    private getNodeElement;
+    private canDropNode;
+    private canDropGroup;
+    private validateMaxHierarchyLevel;
+    private isHoverDescendant;
+    private getPosition;
+    private getPositionY;
+    private getPositionType;
+    private getPositionLevel;
+    /**
+     * @param level if level is defined with go to the defined levle to find ancestor. Sinon on prend le current ancestor
+     */
+    private getNodeAncestors;
+    private getDirectDescendants;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeDragDropDirective, "[igoTreeDragDrop]", never, { "treeControl": { "alias": "treeControl"; "required": true; }; "maxLevel": { "alias": "maxLevel"; "required": false; }; "treeDragDropIsDisabled": { "alias": "treeDragDropIsDisabled"; "required": false; }; }, { "dragStart": "dragStart"; "onDrop": "onDrop"; "onDropError": "onDropError"; }, ["nodes"], never, true, never>;
+    static ngAcceptInputType_treeDragDropIsDisabled: unknown;
+}
+
+/**
+ * @deprecated import the DragAndDropDirective directly
+ */
+declare class IgoDrapDropModule {
+    static forRoot(): ModuleWithProviders<IgoDrapDropModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoDrapDropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoDrapDropModule, never, [typeof DragAndDropDirective, typeof TreeDragDropDirective], [typeof DragAndDropDirective, typeof TreeDragDropDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoDrapDropModule>;
+}
+
+export { DragAndDropDirective, IgoDrapDropModule, TreeDragDropDirective };
+export type { DropPermission, DropPosition, DropPositionType, TreeDropEvent, TreeFlatNode };

package/dynamic-component/index.d.ts

@@ -1,5 +1,188 @@
+import * as i0 from '@angular/core';
+import { ComponentFactory, ViewContainerRef, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+
+interface OnUpdateInputs {
+    onUpdateInputs: () => void;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * This class is used in the DynamicComponentOutlet component. It holds
+ * a reference to a component factory and can render that component
+ * in a target element on demand. It's also possible to set inputs
+ * and to subscribe to outputs.
  */
-/// <amd-module name="@igo2/common/dynamic-component" />
-export * from './public_api';
+declare class DynamicComponent<C> {
+    private componentFactory;
+    /**
+     * Component reference
+     */
+    private componentRef;
+    /**
+     * Subscriptions to the component's outputs. Those need
+     * to be unsubscribed when the component is destroyed.
+     */
+    private subscriptions;
+    /**
+     * Component target element
+     */
+    private target;
+    /**
+     * Component inputs
+     */
+    private inputs;
+    /**
+     * Subscriptions to the component's async inputs
+     */
+    private inputs$$;
+    /**
+     * Subscribers to the component's outputs
+     */
+    private subscribers;
+    constructor(componentFactory: ComponentFactory<C>);
+    /**
+     * Render the component to a target element.
+     * Set it's inputs and subscribe to it's outputs.
+     * @param target Target element
+     */
+    setTarget(target: ViewContainerRef): void;
+    /**
+     * Destroy this component. That means, removing from it's target
+     * element and unsubscribing to it's outputs.
+     */
+    destroy(): void;
+    /**
+     * Update the component inputs. This is an update so any
+     * key not defined won't be overwritten.
+     */
+    updateInputs(inputs: Record<string, any>): void;
+    /**
+     * Set an instance's input value
+     * @param instance Component instance
+     * @param key Input key
+     * @param value Input value
+     */
+    private setInputValue;
+    /**
+     * Update the component subscribers. This is an update so any
+     * key not defined won't be overwritten.
+     */
+    updateSubscribers(subscribers: Record<string, (event: any) => void>): void;
+    /**
+     * Subscribe to an observable input and update the component's input value
+     * accordingly
+     * @param key Input key
+     * @param observable Observable
+     */
+    private observeInput;
+    /**
+     * Unsubscribe to an observable input
+     * @param key Input key
+     */
+    private unobserveInput;
+    /**
+     * Unsubscribe to all outputs.
+     */
+    private unobserveAllInputs;
+    /**
+     * Unsubscribe to all outputs.
+     */
+    private unsubscribeAll;
+}
+
+/**
+ * Service to creates DynamicComponent instances from base component classes
+ */
+declare class DynamicComponentService {
+    private resolver;
+    /**
+     * Creates a DynamicComponent instance from a base component class
+     * @param componentCls The component class
+     * @returns DynamicComponent instance
+     */
+    create(componentCls: any): DynamicComponent<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicComponentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicComponentService>;
+}
+
+declare class DynamicOutletComponent implements OnChanges, OnDestroy {
+    private dynamicComponentService;
+    private cdRef;
+    /**
+     * The dynamic component base class or the dynamic component itself
+     */
+    component: DynamicComponent<any> | any;
+    /**
+     * The dynamic component inputs
+     */
+    inputs: Record<string, any>;
+    /**
+     * The subscribers to the dynamic component outputs
+     */
+    subscribers: Record<string, (event: any) => void>;
+    /**
+     * The dynamic component
+     */
+    private dynamicComponent;
+    /**
+     * The view element to render the component to
+     * @ignore
+     */
+    private target;
+    /**
+     * If the dynamic component changes, create it.
+     * If the inputs or subscribers change, update the current component's
+     * inputs or subscribers.
+     * @internal
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Destroy the dynamic component and all it's subscribers
+     * @internal
+     */
+    ngOnDestroy(): void;
+    /**
+     * Create a  DynamicComponent out of the component class and render it.
+     * @internal
+     */
+    private createComponent;
+    /**
+     * Create and render the dynamic component. Set it's inputs and subscribers
+     * @internal
+     */
+    private renderComponent;
+    /**
+     * Update the dynamic component inputs. This is an update so any
+     * key not defined won't be overwritten.
+     * @internal
+     */
+    private updateInputs;
+    /**
+     * Update the dynamic component subscribers. This is an update so any
+     * key not defined won't be overwritten.
+     * @internal
+     */
+    private updateSubscribers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicOutletComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicOutletComponent, "igo-dynamic-outlet", never, { "component": { "alias": "component"; "required": false; }; "inputs": { "alias": "inputs"; "required": false; }; "subscribers": { "alias": "subscribers"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the DynamicOutletComponent directly
+ */
+declare class IgoDynamicComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoDynamicComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoDynamicComponentModule, never, [typeof DynamicOutletComponent], [typeof DynamicOutletComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoDynamicComponentModule>;
+}
+
+/**
+ * @deprecated import the DynamicOutletComponent directly
+ */
+declare class IgoDynamicOutletModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoDynamicOutletModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoDynamicOutletModule, never, [typeof DynamicOutletComponent], [typeof DynamicOutletComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoDynamicOutletModule>;
+}
+
+export { DynamicComponent, DynamicComponentService, DynamicOutletComponent, IgoDynamicComponentModule, IgoDynamicOutletModule };
+export type { OnUpdateInputs };