@alauda-fe/common 1.0.0-next.0

package/graph-canvas/components/graph-links.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class GraphLinksComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphLinksComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraphLinksComponent, "acl-graph-links", never, {}, {}, never, ["[aclGraphLink]"], false, never>;
+}

package/graph-canvas/components/graph-node.directive.d.ts

@@ -0,0 +1,15 @@
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { GraphStoreService } from '../graph-store.service';
+import { NodeID } from '../types';
+import * as i0 from "@angular/core";
+export declare class GraphNodeDirective implements OnInit, OnDestroy {
+    private readonly el;
+    private readonly store;
+    id: NodeID;
+    hostRect: () => import("../types").Rect;
+    constructor(el: ElementRef<HTMLElement>, store: GraphStoreService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphNodeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GraphNodeDirective, "[aclGraphNode]", never, { "id": { "alias": "aclGraphNode"; "required": false; }; }, {}, never, never, false, never>;
+}

package/graph-canvas/graph-canvas.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/graph-canvas.component";
+import * as i2 from "./components/graph-actions.component";
+import * as i3 from "./components/graph-links.component";
+import * as i4 from "./components/graph-link.component";
+import * as i5 from "./components/graph-node.directive";
+import * as i6 from "@angular/common";
+import * as i7 from "@alauda/ui";
+import * as i8 from "../translate/translate.module";
+export declare class GraphCanvasModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphCanvasModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GraphCanvasModule, [typeof i1.GraphCanvasComponent, typeof i2.GraphActionsComponent, typeof i3.GraphLinksComponent, typeof i4.GraphLinkComponent, typeof i5.GraphNodeDirective], [typeof i6.CommonModule, typeof i7.IconModule, typeof i7.ButtonModule, typeof i8.TranslateModule], [typeof i1.GraphCanvasComponent, typeof i2.GraphActionsComponent, typeof i3.GraphLinksComponent, typeof i4.GraphLinkComponent, typeof i5.GraphNodeDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GraphCanvasModule>;
+}

package/graph-canvas/graph-store.service.d.ts

@@ -0,0 +1,19 @@
+import { GraphNode, NodeID } from './types';
+import * as i0 from "@angular/core";
+export declare class GraphStoreService {
+    private nodeStore;
+    private surfaceNode;
+    private scale;
+    private readonly nodeChanged$$;
+    private readonly nodeChanged$;
+    registerSurfaceNode(surface: GraphNode): void;
+    registerNode(id: NodeID, node: GraphNode): void;
+    unregisterNode(id: NodeID): void;
+    getNode(id: NodeID): GraphNode;
+    getSurfaceNode(): GraphNode;
+    nodeChanged(): import("rxjs").Observable<void>;
+    getScale(): number;
+    setScale(scale: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphStoreService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GraphStoreService>;
+}

package/graph-canvas/public-api.d.ts

@@ -0,0 +1,7 @@
+export * from './graph-canvas.module';
+export * from './components/graph-actions.component';
+export * from './components/graph-canvas.component';
+export * from './components/graph-link.component';
+export * from './components/graph-links.component';
+export * from './components/graph-node.directive';
+export * from './types';

package/graph-canvas/types.d.ts

@@ -0,0 +1,30 @@
+export interface TransformState {
+    origin: [OriginX, OriginY];
+    translate: readonly [number, number];
+    scale: number;
+}
+export interface Rects {
+    canvasRect: Rect;
+    surfaceRect: Rect;
+}
+export interface Rect {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    width: number;
+    height: number;
+    offsetTop: number;
+    offsetLeft: number;
+    offsetWidth: number;
+    offsetHeight: number;
+}
+export type TransformAction = (transform: TransformState, rects: Rects) => Partial<TransformState>;
+export type NodeID = string | number;
+export interface GraphNode {
+    getRect: () => Rect;
+}
+export type OriginX = 'center' | 'left' | 'right';
+export type OriginY = 'center' | 'top' | 'bottom';
+export type NodeEdge = 'top' | 'bottom' | 'left' | 'right';
+export type Points = [[number, number], [number, number]];

package/graph-canvas/utils.d.ts

@@ -0,0 +1,2 @@
+import { Rect } from './types';
+export declare function getRect(el: HTMLElement): Rect;

package/grid-layout/components/grid/component.d.ts

@@ -0,0 +1,53 @@
+import { AfterContentChecked, AfterContentInit, ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, OnInit, QueryList, Renderer2, SimpleChanges, ViewContainerRef } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { GridLayoutService } from '../../grid-layout.service';
+import { GridPlaceholderService } from '../../grid-placeholder.service';
+import { DragEndEvent, DragStartEvent, GridLayout, ResizeStartEvent, GridCfg, GridItemRenderData, ResizeEndEvent, ItemResizeEvent } from '../../type';
+import { GridItemComponent } from '../grid-items/component';
+import * as i0 from "@angular/core";
+export declare class GridLayoutComponent implements OnInit, OnChanges, AfterContentChecked, AfterContentInit, OnDestroy {
+    elementRef: ElementRef;
+    viewContainerRef: ViewContainerRef;
+    private readonly renderer;
+    private readonly ngZone;
+    private readonly gridPlaceholderService;
+    private readonly document;
+    private readonly gridLayoutService;
+    /** Query list of grid items that are being rendered. */
+    gridItems: QueryList<GridItemComponent>;
+    layoutUpdated: EventEmitter<GridLayout>;
+    dragStarted: EventEmitter<DragStartEvent>;
+    resizeStarted: EventEmitter<ResizeStartEvent>;
+    dragEnded: EventEmitter<DragEndEvent>;
+    resizeEnded: EventEmitter<ResizeEndEvent>;
+    gridItemResize: EventEmitter<ItemResizeEvent>;
+    scrollableParent: HTMLElement | Document | string | null;
+    scrollableParent$: Observable<HTMLElement | Document | string | null>;
+    id: string;
+    preventCollision: boolean;
+    scrollSpeed: number;
+    compactType: import("../../utils/react-grid-layout.utils").CompactType;
+    rowHeight: number;
+    cols: number;
+    layout: GridLayout;
+    gutter: number;
+    private lastLayout;
+    destroy$$: Subject<void>;
+    get config(): GridCfg;
+    get hostElement(): HTMLElement;
+    constructor(elementRef: ElementRef, viewContainerRef: ViewContainerRef, renderer: Renderer2, ngZone: NgZone, gridPlaceholderService: GridPlaceholderService, document: Document, gridLayoutService: GridLayoutService);
+    ngOnInit(): void;
+    private lastLayoutId;
+    private markLayoutIdChange;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
+    ngOnDestroy(): void;
+    refreshLayout(dashIdChange: boolean): GridLayout;
+    compactLayout(dashIdChange: boolean): void;
+    getItemRenderData(itemId: string): GridItemRenderData;
+    private initSubscriptions;
+    private handleAction$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridLayoutComponent, "acl-grid-layout", never, { "scrollableParent": { "alias": "scrollableParent"; "required": false; }; "id": { "alias": "id"; "required": false; }; "preventCollision": { "alias": "preventCollision"; "required": false; }; "scrollSpeed": { "alias": "scrollSpeed"; "required": false; }; "compactType": { "alias": "compactType"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "gutter": { "alias": "gutter"; "required": false; }; }, { "layoutUpdated": "layoutUpdated"; "dragStarted": "dragStarted"; "resizeStarted": "resizeStarted"; "dragEnded": "dragEnded"; "resizeEnded": "resizeEnded"; "gridItemResize": "gridItemResize"; }, ["gridItems"], ["*"], false, never>;
+}

package/grid-layout/components/grid-items/component.d.ts

@@ -0,0 +1,56 @@
+import { AfterContentInit, ElementRef, EventEmitter, NgZone, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { GridItemPlaceholderDirective } from '../../directives/placeholder.directive';
+import { GridLayoutService } from '../../grid-layout.service';
+import * as i0 from "@angular/core";
+export declare class GridItemComponent implements OnInit, OnDestroy, AfterContentInit {
+    elementRef: ElementRef;
+    private readonly document;
+    private readonly renderer;
+    private readonly ngZone;
+    private readonly layoutService;
+    id: string;
+    private readonly dragHandles;
+    private readonly resizeHandles;
+    private readonly removeHandles;
+    resizeElem: ElementRef;
+    removeElem: ElementRef;
+    placeholder: GridItemPlaceholderDirective;
+    minW?: number;
+    minH?: number;
+    maxW?: number;
+    maxH?: number;
+    /** CSS transition style */
+    transition: string;
+    /** Minimum amount of pixels that the user should move before it starts the drag sequence. */
+    dragStartThreshold: number;
+    /** Whether the item is draggable or not. Defaults to true. */
+    draggable: boolean;
+    draggable$: Observable<boolean>;
+    /** Whether the item is resizable or not. Defaults to true. */
+    resizable: boolean;
+    resizable$: Observable<boolean>;
+    removable: boolean;
+    removable$: Observable<boolean>;
+    destroy$$: Subject<void>;
+    private readonly dragStartSubject;
+    private readonly resizeStartSubject;
+    dragStart$: Observable<MouseEvent>;
+    resizeStart$: Observable<MouseEvent>;
+    constructor(elementRef: ElementRef, document: Document, renderer: Renderer2, ngZone: NgZone, layoutService: GridLayoutService);
+    remove: EventEmitter<any>;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    setStyles({ top, left, width, height, }: {
+        top: string;
+        left: string;
+        width?: string;
+        height?: string;
+    }, animation: boolean): void;
+    private setupDragStartListener;
+    private setupRemoveListener;
+    private setupResizeStartListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridItemComponent, "acl-grid-item", never, { "id": { "alias": "id"; "required": false; }; "minW": { "alias": "minW"; "required": false; }; "minH": { "alias": "minH"; "required": false; }; "maxW": { "alias": "maxW"; "required": false; }; "maxH": { "alias": "maxH"; "required": false; }; "transition": { "alias": "transition"; "required": false; }; "dragStartThreshold": { "alias": "dragStartThreshold"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; }, { "remove": "remove"; }, ["placeholder", "dragHandles", "resizeHandles", "removeHandles"], ["*"], false, never>;
+}

package/grid-layout/constant.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_LAYOUT_COLUMNS = 24;
+export declare const DEFAULT_ROW_HEIGHT = 10;
+export declare const DEFAULT_GUTTER = 0;

package/grid-layout/directives/drag-handler.directive.d.ts

@@ -0,0 +1,11 @@
+import { ElementRef, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const GRID_DRAG_HANDLER: InjectionToken<GridDragHandlerDirective>;
+/** Handler that can be used to drag a grid item. */
+export declare class GridDragHandlerDirective {
+    element: ElementRef<HTMLElement>;
+    clazz: string;
+    constructor(element: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridDragHandlerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridDragHandlerDirective, "[aclGridDragHandler]", never, {}, {}, never, never, false, never>;
+}

package/grid-layout/directives/placeholder.directive.d.ts

@@ -0,0 +1,12 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const GRID_ITEM_PLACEHOLDER: InjectionToken<GridItemPlaceholderDirective<any>>;
+export declare class GridItemPlaceholderDirective<T = any> {
+    templateRef: TemplateRef<T>;
+    clazz: string;
+    /** Context data. */
+    data: T;
+    constructor(templateRef: TemplateRef<T>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridItemPlaceholderDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridItemPlaceholderDirective<any>, "[aclGridItemPlaceholder]ng-template", never, { "data": { "alias": "data"; "required": false; }; }, {}, never, never, false, never>;
+}

package/grid-layout/directives/remove-handler.directive.d.ts

@@ -0,0 +1,9 @@
+import { ElementRef, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const GRID_REMOVE_HANDLER: InjectionToken<GridRemoveHandlerDirective>;
+export declare class GridRemoveHandlerDirective {
+    element: ElementRef<HTMLElement>;
+    constructor(element: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridRemoveHandlerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridRemoveHandlerDirective, "[aclGridRemoveHandler]", never, {}, {}, never, never, false, never>;
+}

package/grid-layout/directives/resize-handler.directive.d.ts

@@ -0,0 +1,11 @@
+import { ElementRef, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const GRID_RESIZE_HANDLER: InjectionToken<GridResizeHandlerDirective>;
+/** Handler that can be used to drag a grid item */
+export declare class GridResizeHandlerDirective {
+    element: ElementRef<HTMLElement>;
+    clazz: string;
+    constructor(element: ElementRef<HTMLElement>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridResizeHandlerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridResizeHandlerDirective, "[aclGridResizeHandler]", never, {}, {}, never, never, false, never>;
+}

package/grid-layout/grid-layout.service.d.ts

@@ -0,0 +1,49 @@
+import { Observable, ReplaySubject, Subject } from 'rxjs';
+import { Dictionary } from '../core';
+import { GridLayoutComponent } from './components/grid/component';
+import { GridItemComponent } from './components/grid-items/component';
+import { DragActionType, GridItemClientRect, GridItemRenderData, GridLayout, GridLayoutItem } from '.';
+import * as i0 from "@angular/core";
+export declare class GridLayoutService {
+    gridComponent: GridLayoutComponent;
+    get gridConfig(): import("./type").GridCfg;
+    gridItemsRenderData: Dictionary<GridItemRenderData>;
+    gridHeight: number;
+    scrollDifference$: Observable<{
+        top: number;
+        left: number;
+    }>;
+    registerGridComponent(gridComponent: GridLayoutComponent): void;
+    calculateRenderData(_updateLayout?: GridLayoutItem[]): void;
+    gridRenderHeight$$: ReplaySubject<number>;
+    gridRenderItemsData$$: Subject<{
+        data: Dictionary<GridItemRenderData>;
+        animation: boolean;
+    }>;
+    flushRenderItemsData(animation?: boolean): void;
+    flushRenderData(animation?: boolean): void;
+    lastLayout: GridLayout;
+    setLastLayout(layout: GridLayout): void;
+    layoutWhenAction(gridItem: GridItemComponent, type: DragActionType, { pointerDownEvent, pointerDragEvent, }: {
+        pointerDownEvent: MouseEvent;
+        pointerDragEvent: MouseEvent;
+    }, scrollDifference: {
+        top: number;
+        left: number;
+    }, dragElemClientRect: GridItemClientRect, gridElemClientRect: GridItemClientRect): {
+        gridData: Dictionary<GridItemRenderData<number>>;
+        layout: {
+            id: string;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            minW?: number;
+            minH?: number;
+            maxW?: number;
+            maxH?: number;
+        }[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridLayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridLayoutService>;
+}

package/grid-layout/grid-placeholder.service.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef, Renderer2, ViewContainerRef } from '@angular/core';
+import { GridItemPlaceholderDirective } from './directives/placeholder.directive';
+import { GridItemClientRect, GridItemRenderData } from '.';
+import * as i0 from "@angular/core";
+export declare class GridPlaceholderService {
+    private readonly renderer;
+    /** reference to the view of the placeholder element. */
+    private placeholderRef;
+    /** element that is rendered as placeholder when a grid item being dragged */
+    placeholder: HTMLElement | null;
+    constructor(renderer: Renderer2);
+    updatePlaceHolder(data: GridItemRenderData): void;
+    createPlaceholderElement(clientRect: GridItemClientRect, elementRef: ElementRef, viewContainerRef: ViewContainerRef, gridItemPlaceholder?: GridItemPlaceholderDirective): void;
+    destroyPlaceholder(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridPlaceholderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridPlaceholderService>;
+}

package/grid-layout/index.d.ts

@@ -0,0 +1,10 @@
+export * from './module';
+export * from './constant';
+export * from './type';
+export * from './utils/grid.utils';
+export * from './directives/drag-handler.directive';
+export * from './directives/placeholder.directive';
+export * from './directives/remove-handler.directive';
+export * from './directives/resize-handler.directive';
+export * from './components/grid/component';
+export * from './components/grid-items/component';

package/grid-layout/module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/grid/component";
+import * as i2 from "./components/grid-items/component";
+import * as i3 from "./directives/drag-handler.directive";
+import * as i4 from "./directives/resize-handler.directive";
+import * as i5 from "./directives/remove-handler.directive";
+import * as i6 from "./directives/placeholder.directive";
+import * as i7 from "@angular/common";
+import * as i8 from "@alauda/ui";
+export declare class GridLayoutModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridLayoutModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GridLayoutModule, [typeof i1.GridLayoutComponent, typeof i2.GridItemComponent, typeof i3.GridDragHandlerDirective, typeof i4.GridResizeHandlerDirective, typeof i5.GridRemoveHandlerDirective, typeof i6.GridItemPlaceholderDirective], [typeof i7.CommonModule, typeof i8.IconModule], [typeof i1.GridLayoutComponent, typeof i2.GridItemComponent, typeof i3.GridDragHandlerDirective, typeof i4.GridResizeHandlerDirective, typeof i5.GridRemoveHandlerDirective, typeof i6.GridItemPlaceholderDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GridLayoutModule>;
+}

package/grid-layout/type.d.ts

@@ -0,0 +1,65 @@
+import { GridItemComponent } from './components/grid-items/component';
+import { CompactType } from './utils/react-grid-layout.utils';
+export type GridItemDimension = 'w' | 'h' | undefined;
+export type DragActionType = 'drag' | 'resize';
+export type COMPACT_TYPE = 'HORIZONTAL' | 'VERTICAL' | 'FREE';
+export declare const GridCompactType: Record<COMPACT_TYPE, CompactType>;
+export type GridCompactType = (typeof GridCompactType)[keyof typeof GridCompactType];
+export type GridLayoutItem<Extra = unknown> = {
+    id: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    minW?: number;
+    minH?: number;
+    maxW?: number;
+    maxH?: number;
+} & Extra;
+export type GridLayout<Extra = unknown> = Array<GridLayoutItem<Extra>>;
+export interface GridItemClientRect {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+    width?: number;
+    height?: number;
+}
+export interface GridItemDraggingInfo {
+    pointerDownEvent: MouseEvent;
+    pointerDragEvent: MouseEvent;
+    gridElemClientRect: GridItemClientRect;
+    dragElemClientRect: GridItemClientRect;
+    scrollDifference: {
+        top: number;
+        left: number;
+    };
+}
+export interface GridItemRenderData<T = number> {
+    id: string;
+    top: T;
+    left: T;
+    width: T;
+    height: T;
+}
+export interface GridCfg {
+    cols: number;
+    rowHeight: number;
+    layout: GridLayoutItem[];
+    preventCollision?: boolean;
+    gutter: number;
+}
+export interface DragResizeEvent {
+    layout: GridLayout;
+    layoutItem: GridLayoutItem;
+    gridItemRef: GridItemComponent;
+}
+export type DragStartEvent = DragResizeEvent;
+export type ResizeStartEvent = DragResizeEvent;
+export type DragEndEvent = DragResizeEvent;
+export type ResizeEndEvent = DragResizeEvent;
+export interface ItemResizeEvent {
+    width: number;
+    height: number;
+    gridItemRef: GridItemComponent;
+}

package/grid-layout/utils/client-rect.utils.d.ts

@@ -0,0 +1,2 @@
+import { GridItemClientRect } from '..';
+export declare function getClientRectSnapshot(element: Element): GridItemClientRect;

package/grid-layout/utils/grid.utils.d.ts

@@ -0,0 +1,30 @@
+import { Dictionary } from '../../public-api';
+import { GridItemComponent } from '../components/grid-items/component';
+import { DragResizeEvent, GridCfg, GridCompactType, GridItemClientRect, GridItemDraggingInfo, GridItemRenderData, GridLayout, GridLayoutItem } from '../type';
+import { CompactType } from './react-grid-layout.utils';
+export declare function trackById(_index: number, item: {
+    id: string;
+}): string;
+/**
+ * call react-grid-layout utils 'compact()' function and return the compacted layout.
+ */
+export declare function compactGridLayout(layout: GridLayout, compactType: GridCompactType, cols: number): GridLayout;
+/** Returns a Dictionary where the key is the id and the value is the change applied to that item. If no changes Dictionary is empty. */
+export declare function getGetGridLayoutDiff(gridLayoutA: GridLayoutItem[], gridLayoutB: GridLayoutItem[]): Dictionary<{
+    change: 'move' | 'resize' | 'moveresize';
+}>;
+export declare function gridItemDragging(gridItem: GridItemComponent, config: GridCfg, compactType: CompactType, draggingData: GridItemDraggingInfo): {
+    layout: GridLayoutItem[];
+    draggedItemPos: GridItemClientRect;
+};
+export declare function gridItemResizing(gridItem: GridItemComponent, config: GridCfg, compactType: CompactType, draggingData: GridItemDraggingInfo): {
+    layout: GridLayoutItem[];
+    draggedItemPos: GridItemClientRect;
+};
+/** Returns true if both item1 and item2 GridLayoutItems are equivalent. */
+export declare function isGridItemLayoutItemEqual(item1: GridLayoutItem, item2: GridLayoutItem): boolean;
+export declare function getGridHeight(layout: GridLayout, rowHeight: number, gutter: number): number;
+export declare function getDragResizeEventData(gridItem: GridItemComponent, layout: GridLayout): DragResizeEvent;
+export declare function layoutToRenderItems(config: GridCfg, width: number, layout?: GridLayout): Dictionary<GridItemRenderData>;
+export declare function parseRenderItemToPixels(renderItem: GridItemRenderData): GridItemRenderData<string>;
+export declare function correctLayout(layout: GridLayout, cols?: number): GridLayout;

package/grid-layout/utils/mouse.utils.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from 'rxjs';
+/**
+ * Emits when a 'mousemove' event gets fired.
+ * @param element, html element where to  listen the events.
+ */
+export declare function getMouseMove$(element: HTMLElement): Observable<MouseEvent>;
+/**
+ * Emits when a mousedown emits..
+ * @param element, html element where to  listen the events.
+ */
+export declare function getMouseClick$(element: HTMLElement): Observable<MouseEvent>;
+/**
+ * Emits when a mousedown emits..
+ * @param element, html element where to  listen the events.
+ */
+export declare function getMouseDown$(element: HTMLElement): Observable<MouseEvent>;
+/**
+ * Emits when a there is a 'mouseup'.
+ * @param element, html element where to  listen the events.
+ */
+export declare function getMouseEnd$(element: HTMLElement): Observable<MouseEvent>;
+export declare function getPointerPageX(event: MouseEvent): number;
+export declare function getPointerPageY(event: MouseEvent): number;
+export declare function accessPointerMoveThreshold(sourceEvt: MouseEvent, moveEvent: MouseEvent, threshold: number): boolean;

package/grid-layout/utils/operator.d.ts

@@ -0,0 +1,3 @@
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+export declare function runOutsideZone$<T>(zone: NgZone): (source: Observable<T>) => Observable<T>;