@igo2/common 19.0.3 → 20.0.0-next.2

package/table/index.d.ts

@@ -1,5 +1,107 @@
+import * as i0 from '@angular/core';
+import { OnChanges, OnInit, AfterViewInit, EventEmitter, ElementRef, ModuleWithProviders } from '@angular/core';
+import { SelectionModel } from '@angular/cdk/collections';
+import { MatSort } from '@angular/material/sort';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { DataSource } from '@angular/cdk/table';
+
+declare class TableDatabase {
+    /** Stream that emits whenever the data has been modified. */
+    dataChange: BehaviorSubject<any[]>;
+    get data(): any[];
+    constructor(data?: any);
+    set(data: any): void;
+    add(item: any): void;
+    remove(item: any): void;
+}
+
+declare enum TableActionColor {
+    primary = 0,
+    accent = 1,
+    warn = 2
+}
+
+interface TableColumn {
+    name: string;
+    title: string;
+    sortable?: boolean;
+    filterable?: boolean;
+    displayed?: boolean;
+    html?: boolean;
+}
+type RowClassFunc = (row: any) => Record<string, string>;
+type CellClassFunc = (row: any, column: TableColumn) => Record<string, string>;
+type ClickAction = (item: any) => void;
+interface TableAction {
+    icon: string;
+    color?: TableActionColor;
+    click: ClickAction;
+}
+interface TableModel {
+    columns: TableColumn[];
+    actions?: TableAction[];
+    selectionCheckbox?: boolean;
+    rowClassFunc?: RowClassFunc;
+    cellClassFunc?: CellClassFunc;
+}
+
+declare class TableDataSource extends DataSource<any> {
+    private _database;
+    private _model;
+    private _sort;
+    get filter(): string;
+    set filter(filter: string);
+    private _filterChange;
+    constructor(_database: TableDatabase, _model: TableModel, _sort: MatSort);
+    connect(): Observable<any[]>;
+    disconnect(): void;
+    getFilteredData(data: any): any[];
+    getSortedData(data: any): any[];
+}
+
+declare class TableComponent implements OnChanges, OnInit, AfterViewInit {
+    get database(): TableDatabase;
+    set database(value: TableDatabase);
+    private _database;
+    get model(): TableModel;
+    set model(value: TableModel);
+    private _model;
+    get hasFilterInput(): boolean;
+    set hasFilterInput(value: boolean);
+    private _hasFIlterInput;
+    displayedColumns: any;
+    dataSource: TableDataSource | null;
+    selection: SelectionModel<any>;
+    select: EventEmitter<{
+        added: any[];
+        removed: any[];
+        source: SelectionModel<any>;
+    }>;
+    filter: ElementRef;
+    sort: MatSort;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(change: any): void;
+    getActionColor(colorId: number): string;
+    getValue(row: any, key: any): any;
+    /** Whether the number of selected elements matches the total number of rows. */
+    isAllSelected(): boolean;
+    /** Selects all rows if they are not all selected; otherwise clear selection. */
+    masterToggle(): void;
+    handleClickAction(event: any, action: any, row: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "igo-table", never, { "database": { "alias": "database"; "required": false; }; "model": { "alias": "model"; "required": false; }; "hasFilterInput": { "alias": "hasFilterInput"; "required": false; }; }, { "select": "select"; }, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * @deprecated import the TableComponent directly
  */
-/// <amd-module name="@igo2/common/table" />
-export * from './public_api';
+declare class IgoTableModule {
+    static forRoot(): ModuleWithProviders<IgoTableModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoTableModule, never, [typeof TableComponent], [typeof TableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoTableModule>;
+}
+
+export { IgoTableModule, TableActionColor, TableComponent, TableDataSource, TableDatabase };
+export type { CellClassFunc, ClickAction, RowClassFunc, TableAction, TableColumn, TableModel };

package/tool/index.d.ts

@@ -1,5 +1,291 @@
+import { IconSvg } from '@igo2/common/icon';
+import { BehaviorSubject, Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { OnInit, OnDestroy, ModuleWithProviders } from '@angular/core';
+import { ActionStore } from '@igo2/common/action';
+
+interface Tool {
+    name: string;
+    component: any;
+    title?: string;
+    icon?: string | IconSvg;
+    tooltip?: string;
+    global?: boolean;
+    options?: Record<string, any>;
+    parent?: string;
+    children?: string[];
+    id?: string;
+}
+interface ToolboxOptions {
+    toolbar?: string[];
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * Service where all available tools and their component are registered.
  */
-/// <amd-module name="@igo2/common/tool" />
-export * from './public_api';
+declare class Toolbox {
+    private options;
+    /**
+     * Observable of the active tool
+     */
+    activeTool$: BehaviorSubject<Tool>;
+    /**
+     * Ordered list of tool names to display in a toolbar
+     */
+    toolbar$: BehaviorSubject<string[]>;
+    /**
+     * Observable of the active tool
+     */
+    private activeTool$$;
+    /**
+     * Active tool history. Useful for activating the previous tool.
+     */
+    private activeToolHistory;
+    private previousToolName;
+    private currentToolName;
+    /**
+     * Tool store
+     */
+    private store;
+    get tools$(): BehaviorSubject<Tool[]>;
+    constructor(options?: ToolboxOptions);
+    /**
+     * Destroy the toolbox
+     */
+    destroy(): void;
+    /**
+     * Return a tool
+     * @param name Tool name
+     * @returns tool Tool
+     */
+    getTool(name: string): Tool;
+    /**
+     * Return all tools
+     * @returns Array of tools
+     */
+    getTools(): Tool[];
+    /**
+     * Set tool configurations
+     * @param tools Tools
+     */
+    setTools(tools: Tool[]): void;
+    /**
+     * Get toolbar
+     * @returns Toolbar value
+     */
+    getToolbar(): string[];
+    /**
+     * Set toolbar
+     * @param toolbar A list of tool names
+     */
+    setToolbar(toolbar: string[]): void;
+    /**
+     * Activate a tool (and deactivate other tools)
+     * @param name Tool name
+     * @param options Tool options
+     */
+    activateTool(name: string, options?: Record<string, any>): void;
+    /**
+     * Activate the previous tool, if any
+     */
+    activatePreviousTool(): void;
+    getCurrentPreviousToolName(): [string, string];
+    /**
+     * Activate the tool below, if any
+     */
+    /**
+     * Activate the tool above, if any
+     */
+    /**
+     * Deactivate the active tool
+     */
+    deactivateTool(): void;
+    /**
+     * Initialize the tool store and start observing the active tool
+     */
+    private initStore;
+    /**
+     * Set the active tool and update the tool history
+     * @param tool Tool
+     */
+    private setActiveTool;
+    /**
+     * Clear the tool history
+     */
+    private clearActiveToolHistory;
+}
+
+/**
+ * Service where runtime tool configurations are registered
+ */
+declare class ToolService {
+    static tools: Record<string, Tool>;
+    /**
+     * Toolbox that holds main tools
+     */
+    toolbox: Toolbox;
+    static register(tool: Tool): void;
+    constructor();
+    /**
+     * Return a tool
+     * @param name Tool name
+     * @returns tool Tool
+     */
+    getTool(name: string): Tool;
+    /**
+     * Return all tools
+     * @returns tTols
+     */
+    getTools(): Tool[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToolService>;
+}
+
+declare function ToolComponent(tool: Partial<Tool>): (cls: any) => any;
+
+type ToolboxColor = 'white' | 'grey' | 'primary';
+
+declare class ToolboxComponent implements OnInit, OnDestroy {
+    /**
+     * Observable of the active tool
+     */
+    activeTool$: BehaviorSubject<Tool>;
+    get isActive(): boolean;
+    /**
+     * Store of actions that toggle tools
+     */
+    actionStore: ActionStore;
+    /**
+     * Observable of he anmation state
+     */
+    animation$: BehaviorSubject<string>;
+    /**
+     * Observable of the toolbar
+     */
+    toolbar$: BehaviorSubject<string[]>;
+    /**
+     * Whether the Toolbar should display actions' titles
+     */
+    toolbarWithTitle$: Observable<boolean>;
+    /**
+     * Subscription to the active tool
+     */
+    private activeTool$$;
+    /**
+     * Subscription to the toolbar
+     */
+    private toolbar$$;
+    /**
+     * Observable of the ongoing animation. This is useful when
+     * multiple animations are triggered at once i.e. when the user clicks
+     * too fast on different actions
+     */
+    private animating$;
+    /**
+     * Subscription to the ongoing animation
+     */
+    private animating$$;
+    /**
+     * Toolbox
+     */
+    toolbox: Toolbox;
+    /**
+     * Whether the toolbox should animate the first tool entering
+     */
+    animate: boolean;
+    /**
+     * Color of Toolbox
+     */
+    color: ToolboxColor;
+    /**
+     * @ignore
+     */
+    get classColorGrey(): boolean;
+    /**
+     * @ignore
+     */
+    get classColorPrimary(): boolean;
+    /**
+     * Initialize the toolbar and subscribe to the active tool
+     * @internal
+     */
+    ngOnInit(): void;
+    /**
+     * Unsubscribe to the active tool and destroy the action store
+     * @internal
+     */
+    ngOnDestroy(): void;
+    /**
+     * Track the starting animation
+     * @internal
+     */
+    onAnimationStart(): void;
+    /**
+     * Untrack the completed animation
+     * @internal
+     */
+    onAnimationComplete(): void;
+    /**
+     * Return a tool's inputs
+     * @param tool Tool
+     * @returns Tool inputs
+     * @internal
+     */
+    getToolInputs(tool: Tool): Record<string, any>;
+    /**
+     * Initialize an action store
+     * @param toolbar Toolbar
+     */
+    private onToolbarChange;
+    /**
+     * Activate a tool and trigger an animation or not
+     * @param tool Tool to activate
+     */
+    private onActiveToolChange;
+    /**
+     * Set the active tool
+     * @param tool Tool to activate
+     */
+    private setActiveTool;
+    /**
+     * Initialize the toolbar
+     */
+    private setToolbar;
+    /**
+     * Observe the ongoing animation and ignore any incoming animation
+     * while one is still ongoing.
+     * @param callback Callback to execute when the animation completes
+     */
+    private onAnimate;
+    /**
+     * Stop observing an animation when it's complete
+     */
+    private unAnimate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolboxComponent, "igo-toolbox", never, { "toolbox": { "alias": "toolbox"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the ToolboxComponent directly
+ */
+declare class IgoToolboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoToolboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoToolboxModule, never, [typeof ToolboxComponent], [typeof ToolboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoToolboxModule>;
+}
+
+/**
+ * @deprecated import the ToolboxComponent directly
+ */
+declare class IgoToolModule {
+    /**
+     * @deprecated it has no effect
+     */
+    static forRoot(): ModuleWithProviders<IgoToolModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoToolModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoToolModule, never, never, [typeof IgoToolboxModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoToolModule>;
+}
+
+export { IgoToolModule, IgoToolboxModule, ToolComponent, ToolService, Toolbox, ToolboxComponent };
+export type { Tool, ToolboxColor, ToolboxOptions };

package/widget/index.d.ts

@@ -1,5 +1,107 @@
+import { DynamicComponent } from '@igo2/common/dynamic-component';
+import * as i0 from '@angular/core';
+import { EventEmitter, OnDestroy } from '@angular/core';
+
 /**
- * Generated bundle index. Do not edit.
+ * This is the interface a widget component needs to implement. A widget
+ * component is component that can be created dynamically. It needs
+ * to emit the 'complete' and 'cancel' event at some time in it's lifecycle.
+ * Since a widget's inputs are set manually, you may want to implement the 'onUpdateInputs'
+ * method. This method could, for example, trigger the change detection.
  */
-/// <amd-module name="@igo2/common/widget" />
-export * from './public_api';
+interface WidgetComponent {
+    complete: EventEmitter<any>;
+    cancel: EventEmitter<any>;
+}
+
+declare class Widget extends DynamicComponent<WidgetComponent> {
+}
+
+declare class WidgetService {
+    private dynamicComponentService;
+    create(widgetCls: any): Widget;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WidgetService>;
+}
+
+/**
+ * This component dynamically renders a widget. It also subscribes
+ * to the widget's 'cancel' and 'complete' events and destroys it
+ * when any of those event is emitted.
+ */
+declare class WidgetOutletComponent implements OnDestroy {
+    /**
+     * Widget subscribers to 'cancel' and 'complete'
+     * @internal
+     */
+    private baseSubscribers;
+    /**
+     * Widget
+     */
+    widget: DynamicComponent<WidgetComponent>;
+    /**
+     * Widget inputs
+     */
+    inputs: Record<string, any>;
+    /**
+     * Widget subscribers
+     */
+    subscribers: Record<string, (event: any) => void>;
+    /**
+     * Event emitted when the widget emits 'complete'
+     */
+    complete: EventEmitter<any>;
+    /**
+     * Event emitted when the widget emits 'cancel'
+     */
+    cancel: EventEmitter<any>;
+    /**
+     * Destroy the current widget and all it's inner subscriptions
+     * @internal
+     */
+    ngOnDestroy(): void;
+    /**
+     * Get the effective subscribers. That means a combination of the base
+     * subscribers and any subscriber given as input.
+     * @returns Combined subscribers
+     * @internal
+     */
+    getEffectiveSubscribers(): Record<string, (event: any) => void>;
+    /**
+     * When the widget emits 'cancel', propagate that event and destroy
+     * the widget
+     */
+    private onCancel;
+    /**
+     * When the widget emits 'complete', propagate that event and destroy
+     * the widget
+     */
+    private onComplete;
+    /**
+     * Destroy the current widget
+     */
+    private destroyWidget;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetOutletComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetOutletComponent, "igo-widget-outlet", never, { "widget": { "alias": "widget"; "required": false; }; "inputs": { "alias": "inputs"; "required": false; }; "subscribers": { "alias": "subscribers"; "required": false; }; }, { "complete": "complete"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+/**
+ * @deprecated import the WidgetOutletComponent directly
+ */
+declare class IgoWidgetOutletModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoWidgetOutletModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoWidgetOutletModule, never, [typeof WidgetOutletComponent], [typeof WidgetOutletComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoWidgetOutletModule>;
+}
+
+/**
+ * @deprecated import the WidgetOutletComponent directly
+ */
+declare class IgoWidgetModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoWidgetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoWidgetModule, never, [typeof IgoWidgetOutletModule], [typeof IgoWidgetOutletModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoWidgetModule>;
+}
+
+export { IgoWidgetModule, IgoWidgetOutletModule, Widget, WidgetOutletComponent, WidgetService };
+export type { WidgetComponent };