@schneideress/dashboardframework 13.0.0 → 17.0.1

package/gridster/index.d.ts

@@ -0,0 +1,9 @@
+export { GridsterComponent } from './lib/gridster.component';
+export { GridsterItemComponent } from './lib/gridsterItem.component';
+export { GridsterItem } from './lib/gridsterItem.interface';
+export { GridsterComponentInterface } from './lib/gridster.interface';
+export { GridsterConfig, GridType, DisplayGrid, CompactType, Draggable, Resizable, PushDirections } from './lib/gridsterConfig.interface';
+export { GridsterConfigService } from './lib/gridsterConfig.constant';
+export { GridsterModule } from './lib/gridster.module';
+export { GridsterPush } from './lib/gridsterPush.service';
+export { GridsterPushResize } from './lib/gridsterPushResize.service';

package/gridster/lib/gridster.component.d.ts

@@ -0,0 +1,79 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, OnInit, Renderer2, SimpleChanges } from '@angular/core';
+import { Subject } from 'rxjs';
+import { GridsterComponentInterface } from './gridster.interface';
+import { GridsterCompact } from './gridsterCompact.service';
+import { GridsterConfig } from './gridsterConfig.interface';
+import { GridsterConfigS } from './gridsterConfigS.interface';
+import { GridsterEmptyCell } from './gridsterEmptyCell.service';
+import { GridsterItem, GridsterItemComponentInterface } from './gridsterItem.interface';
+import { GridsterRenderer } from './gridsterRenderer.service';
+import * as i0 from "@angular/core";
+export declare class GridsterComponent implements OnInit, OnChanges, OnDestroy, GridsterComponentInterface {
+    renderer: Renderer2;
+    cdRef: ChangeDetectorRef;
+    zone: NgZone;
+    options: GridsterConfig;
+    movingItem: GridsterItem | null;
+    el: HTMLElement;
+    $options: GridsterConfigS;
+    mobile: boolean;
+    curWidth: number;
+    curHeight: number;
+    grid: GridsterItemComponentInterface[];
+    columns: number;
+    rows: number;
+    curColWidth: number;
+    curRowHeight: number;
+    gridColumns: never[];
+    gridRows: never[];
+    windowResize: (() => void) | null;
+    dragInProgress: boolean;
+    emptyCell: GridsterEmptyCell;
+    compact: GridsterCompact;
+    gridRenderer: GridsterRenderer;
+    previewStyle$: EventEmitter<GridsterItem | null>;
+    calculateLayout$: Subject<void>;
+    private resize$;
+    private destroy$;
+    constructor(el: ElementRef, renderer: Renderer2, cdRef: ChangeDetectorRef, zone: NgZone);
+    static checkCollisionTwoItemsForSwaping(item: GridsterItem, item2: GridsterItem): boolean;
+    checkCollisionTwoItems(item: GridsterItem, item2: GridsterItem): boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getCurrentRowHeight(): number;
+    private resize;
+    setOptions(): void;
+    optionsChanged: () => void;
+    ngOnDestroy(): void;
+    onResize: () => void;
+    checkIfToResize(): boolean;
+    checkIfMobile(): boolean;
+    setGridSize(): void;
+    setGridDimensions(): void;
+    private calculateLayout;
+    updateGrid(): void;
+    addItem(itemComponent: GridsterItemComponentInterface): void;
+    removeItem(itemComponent: GridsterItemComponentInterface): void;
+    checkCollision(item: GridsterItem): GridsterItemComponentInterface | boolean;
+    checkGridCollision(item: GridsterItem): boolean;
+    findItemWithItem(item: GridsterItem): GridsterItemComponentInterface | boolean;
+    findItemsWithItem(item: GridsterItem): Array<GridsterItemComponentInterface>;
+    autoPositionItem(itemComponent: GridsterItemComponentInterface): void;
+    getNextPossiblePosition: (newItem: GridsterItem, startingFrom?: {
+        y?: number;
+        x?: number;
+    }) => boolean;
+    getFirstPossiblePosition: (item: GridsterItem) => GridsterItem;
+    getLastPossiblePosition: (item: GridsterItem) => GridsterItem;
+    pixelsToPositionX(x: number, roundingMethod: (x: number) => number, noLimit?: boolean): number;
+    pixelsToPositionY(y: number, roundingMethod: (x: number) => number, noLimit?: boolean): number;
+    positionXToPixels(x: number): number;
+    positionYToPixels(y: number): number;
+    getItemComponent(item: GridsterItem): GridsterItemComponentInterface | undefined;
+    checkCollisionForSwaping(item: GridsterItem): GridsterItemComponentInterface | boolean;
+    findItemWithItemForSwapping(item: GridsterItem): GridsterItemComponentInterface | boolean;
+    previewStyle(drag?: boolean): void;
+    private static getNewArrayLength;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridsterComponent, "gridster", never, { "options": { "alias": "options"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/gridster/lib/gridster.interface.d.ts

@@ -0,0 +1,49 @@
+import { GridsterConfigS } from './gridsterConfigS.interface';
+import { ChangeDetectorRef, NgZone, Renderer2 } from '@angular/core';
+import { Subject } from 'rxjs';
+import { GridsterEmptyCell } from './gridsterEmptyCell.service';
+import { GridsterCompact } from './gridsterCompact.service';
+import { GridsterConfig } from './gridsterConfig.interface';
+import { GridsterItem, GridsterItemComponentInterface } from './gridsterItem.interface';
+import { GridsterRenderer } from './gridsterRenderer.service';
+export declare abstract class GridsterComponentInterface {
+    $options: GridsterConfigS;
+    grid: GridsterItemComponentInterface[];
+    checkCollision: (item: GridsterItem) => GridsterItemComponentInterface | boolean;
+    checkCollisionForSwaping: (item: GridsterItem) => GridsterItemComponentInterface | boolean;
+    positionXToPixels: (x: number) => number;
+    pixelsToPositionX: (x: number, roundingMethod: (x: number) => number, noLimit?: boolean) => number;
+    positionYToPixels: (y: number) => number;
+    pixelsToPositionY: (y: number, roundingMethod: (x: number) => number, noLimit?: boolean) => number;
+    findItemWithItem: (item: GridsterItem) => GridsterItemComponentInterface | boolean;
+    findItemsWithItem: (item: GridsterItem) => GridsterItemComponentInterface[];
+    checkGridCollision: (item: GridsterItem) => boolean;
+    checkCollisionTwoItems: (item: GridsterItem, item2: GridsterItem) => boolean;
+    getItemComponent: (item: GridsterItem) => GridsterItemComponentInterface | undefined;
+    el: HTMLElement;
+    renderer: Renderer2;
+    gridRenderer: GridsterRenderer;
+    cdRef: ChangeDetectorRef;
+    options: GridsterConfig;
+    calculateLayout$: Subject<void>;
+    updateGrid: () => void;
+    movingItem: GridsterItem | null;
+    addItem: (item: GridsterItemComponentInterface) => void;
+    removeItem: (item: GridsterItemComponentInterface) => void;
+    previewStyle: (drag?: boolean) => void;
+    mobile: boolean;
+    curWidth: number;
+    curHeight: number;
+    columns: number;
+    rows: number;
+    curColWidth: number;
+    curRowHeight: number;
+    windowResize: (() => void) | null;
+    setGridDimensions: () => void;
+    dragInProgress: boolean;
+    emptyCell: GridsterEmptyCell;
+    compact: GridsterCompact;
+    zone: NgZone;
+    gridRows: Array<number>;
+    gridColumns: Array<number>;
+}

package/gridster/lib/gridster.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./gridster.component";
+import * as i2 from "./gridsterItem.component";
+export declare class GridsterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<GridsterModule, never, [typeof i1.GridsterComponent, typeof i2.GridsterItemComponent], [typeof i1.GridsterComponent, typeof i2.GridsterItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<GridsterModule>;
+}

package/gridster/lib/gridsterCompact.service.d.ts

@@ -0,0 +1,11 @@
+import { GridsterComponentInterface } from './gridster.interface';
+import { GridsterItem } from './gridsterItem.interface';
+export declare class GridsterCompact {
+    private gridster;
+    constructor(gridster: GridsterComponentInterface);
+    destroy(): void;
+    checkCompact(): void;
+    checkCompactItem(item: GridsterItem): void;
+    private checkCompactMovement;
+    private moveTillCollision;
+}

package/gridster/lib/gridsterConfig.constant.d.ts

@@ -0,0 +1,2 @@
+import { GridsterConfig } from './gridsterConfig.interface';
+export declare const GridsterConfigService: GridsterConfig;

package/gridster/lib/gridsterConfig.interface.d.ts

@@ -0,0 +1,155 @@
+import { GridsterComponentInterface } from './gridster.interface';
+import { GridsterItem, GridsterItemComponentInterface } from './gridsterItem.interface';
+export type gridTypes = 'fit' | 'scrollVertical' | 'scrollHorizontal' | 'fixed' | 'verticalFixed' | 'horizontalFixed';
+export type displayGrids = 'always' | 'onDrag&Resize' | 'none';
+export type compactTypes = 'none' | 'compactUp' | 'compactLeft' | 'compactUp&Left' | 'compactLeft&Up' | 'compactRight' | 'compactUp&Right' | 'compactRight&Up' | 'compactDown' | 'compactDown&Left' | 'compactLeft&Down' | 'compactDown&Right' | 'compactRight&Down';
+export declare enum GridType {
+    Fit = "fit",
+    ScrollVertical = "scrollVertical",
+    ScrollHorizontal = "scrollHorizontal",
+    Fixed = "fixed",
+    VerticalFixed = "verticalFixed",
+    HorizontalFixed = "horizontalFixed"
+}
+export declare enum DisplayGrid {
+    Always = "always",
+    OnDragAndResize = "onDrag&Resize",
+    None = "none"
+}
+export declare enum CompactType {
+    None = "none",
+    CompactUp = "compactUp",
+    CompactLeft = "compactLeft",
+    CompactUpAndLeft = "compactUp&Left",
+    CompactLeftAndUp = "compactLeft&Up",
+    CompactRight = "compactRight",
+    CompactUpAndRight = "compactUp&Right",
+    CompactRightAndUp = "compactRight&Up",
+    CompactDown = "compactDown",
+    CompactDownAndLeft = "compactDown&Left",
+    CompactLeftAndDown = "compactLeft&Down",
+    CompactDownAndRight = "compactDown&Right",
+    CompactRightAndDown = "compactRight&Down"
+}
+export declare enum DirTypes {
+    LTR = "ltr",
+    RTL = "rtl"
+}
+export type dirTypes = 'ltr' | 'rtl';
+export interface GridsterConfig {
+    gridType?: gridTypes;
+    scale?: number;
+    fixedColWidth?: number;
+    fixedRowHeight?: number;
+    keepFixedHeightInMobile?: boolean;
+    keepFixedWidthInMobile?: boolean;
+    setGridSize?: boolean;
+    compactType?: compactTypes;
+    mobileBreakpoint?: number;
+    allowMultiLayer?: boolean;
+    defaultLayerIndex?: number;
+    maxLayerIndex?: number;
+    baseLayerIndex?: number;
+    minCols?: number;
+    maxCols?: number;
+    minRows?: number;
+    maxRows?: number;
+    defaultItemCols?: number;
+    defaultItemRows?: number;
+    maxItemCols?: number;
+    maxItemRows?: number;
+    minItemCols?: number;
+    minItemRows?: number;
+    minItemArea?: number;
+    maxItemArea?: number;
+    addEmptyRowsCount?: number;
+    rowHeightRatio?: number;
+    margin?: number;
+    outerMargin?: boolean;
+    outerMarginTop?: number | null;
+    outerMarginRight?: number | null;
+    outerMarginBottom?: number | null;
+    outerMarginLeft?: number | null;
+    useTransformPositioning?: boolean;
+    scrollSensitivity?: number | null;
+    scrollSpeed?: number;
+    initCallback?: (gridster: GridsterComponentInterface) => void;
+    destroyCallback?: (gridster: GridsterComponentInterface) => void;
+    gridSizeChangedCallback?: (gridster: GridsterComponentInterface) => void;
+    itemChangeCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
+    itemResizeCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
+    itemInitCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
+    itemRemovedCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
+    itemValidateCallback?: (item: GridsterItem) => boolean;
+    draggable?: Draggable;
+    resizable?: Resizable;
+    swap?: boolean;
+    swapWhileDragging?: boolean;
+    pushItems?: boolean;
+    disablePushOnDrag?: boolean;
+    disablePushOnResize?: boolean;
+    disableAutoPositionOnConflict?: boolean;
+    pushDirections?: PushDirections;
+    pushResizeItems?: boolean;
+    displayGrid?: displayGrids;
+    disableWindowResize?: boolean;
+    disableWarnings?: boolean;
+    scrollToNewItems?: boolean;
+    disableScrollHorizontal?: boolean;
+    disableScrollVertical?: boolean;
+    enableBoundaryControl?: boolean;
+    enableEmptyCellClick?: boolean;
+    enableEmptyCellContextMenu?: boolean;
+    enableEmptyCellDrop?: boolean;
+    enableEmptyCellDrag?: boolean;
+    enableOccupiedCellDrop?: boolean;
+    emptyCellClickCallback?: (event: MouseEvent, item: GridsterItem) => void;
+    emptyCellContextMenuCallback?: (event: MouseEvent, item: GridsterItem) => void;
+    emptyCellDropCallback?: (event: DragEvent, item: GridsterItem) => void;
+    emptyCellDragCallback?: (event: MouseEvent, item: GridsterItem) => void;
+    emptyCellDragMaxCols?: number;
+    emptyCellDragMaxRows?: number;
+    ignoreMarginInRow?: boolean;
+    dirType?: dirTypes;
+    api?: {
+        resize?: () => void;
+        optionsChanged?: () => void;
+        getNextPossiblePosition?: (newItem: GridsterItem) => boolean;
+        getFirstPossiblePosition?: (item: GridsterItem) => GridsterItem;
+        getLastPossiblePosition?: (item: GridsterItem) => GridsterItem;
+        getCurrentRowHeight?: () => number;
+        getItemComponent?: (item: GridsterItem) => GridsterItemComponentInterface | undefined;
+    };
+    [propName: string]: any;
+}
+export interface DragBase {
+    enabled?: boolean;
+    stop?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface, event: MouseEvent) => Promise<any> | void;
+    start?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface, event: MouseEvent) => void;
+    delayStart?: number;
+}
+export interface Draggable extends DragBase {
+    ignoreContentClass?: string;
+    ignoreContent?: boolean;
+    dragHandleClass?: string;
+    dropOverItems?: boolean;
+    dropOverItemsCallback?: (source: GridsterItem, target: GridsterItem, grid?: GridsterComponentInterface) => void;
+}
+export interface Resizable extends DragBase {
+    handles?: {
+        s: boolean;
+        e: boolean;
+        n: boolean;
+        w: boolean;
+        se: boolean;
+        ne: boolean;
+        sw: boolean;
+        nw: boolean;
+    };
+}
+export interface PushDirections {
+    north: boolean;
+    east: boolean;
+    south: boolean;
+    west: boolean;
+}

package/gridster/lib/gridsterConfigS.interface.d.ts

@@ -0,0 +1,107 @@
+import { GridsterComponentInterface } from './gridster.interface';
+import { compactTypes, dirTypes, displayGrids, gridTypes } from './gridsterConfig.interface';
+import { GridsterItem, GridsterItemComponentInterface } from './gridsterItem.interface';
+export interface GridsterConfigS {
+    gridType: gridTypes;
+    scale?: number;
+    fixedColWidth: number;
+    fixedRowHeight: number;
+    keepFixedHeightInMobile: boolean;
+    keepFixedWidthInMobile: boolean;
+    setGridSize: boolean;
+    compactType: compactTypes;
+    mobileBreakpoint: number;
+    useBodyForBreakpoint: boolean;
+    allowMultiLayer: boolean;
+    defaultLayerIndex: number;
+    maxLayerIndex: number;
+    baseLayerIndex: number;
+    minCols: number;
+    maxCols: number;
+    minRows: number;
+    maxRows: number;
+    defaultItemCols: number;
+    defaultItemRows: number;
+    maxItemCols: number;
+    maxItemRows: number;
+    minItemCols: number;
+    minItemRows: number;
+    minItemArea: number;
+    maxItemArea: number;
+    addEmptyRowsCount: number;
+    rowHeightRatio: number;
+    margin: number;
+    outerMargin: boolean;
+    outerMarginTop: number | null;
+    outerMarginRight: number | null;
+    outerMarginBottom: number | null;
+    outerMarginLeft: number | null;
+    useTransformPositioning: boolean;
+    scrollSensitivity: number;
+    scrollSpeed: number;
+    draggable: Draggable;
+    resizable: Resizable;
+    swap: boolean;
+    swapWhileDragging: boolean;
+    pushItems: boolean;
+    disablePushOnDrag: boolean;
+    disablePushOnResize: boolean;
+    disableAutoPositionOnConflict: boolean;
+    pushDirections: PushDirections;
+    pushResizeItems: boolean;
+    displayGrid: displayGrids;
+    disableWindowResize: boolean;
+    disableWarnings: boolean;
+    scrollToNewItems: boolean;
+    disableScrollHorizontal?: boolean;
+    disableScrollVertical?: boolean;
+    enableBoundaryControl?: boolean;
+    enableEmptyCellClick: boolean;
+    enableEmptyCellContextMenu: boolean;
+    enableEmptyCellDrop: boolean;
+    enableEmptyCellDrag: boolean;
+    enableOccupiedCellDrop: boolean;
+    emptyCellDragMaxCols: number;
+    emptyCellDragMaxRows: number;
+    ignoreMarginInRow: boolean;
+    dirType: dirTypes;
+    api: {
+        resize: () => void;
+        optionsChanged: () => void;
+        getNextPossiblePosition: (newItem: GridsterItem) => boolean;
+        getFirstPossiblePosition: (item: GridsterItem) => GridsterItem;
+        getLastPossiblePosition: (item: GridsterItem) => GridsterItem;
+        getItemComponent: (item: GridsterItem) => GridsterItemComponentInterface | undefined;
+    };
+    [propName: string]: any;
+}
+export interface DragBase {
+    enabled: boolean;
+    delayStart: number;
+    [propName: string]: any;
+}
+export interface Draggable extends DragBase {
+    ignoreContentClass: string;
+    ignoreContent: boolean;
+    dragHandleClass: string;
+    dropOverItems: boolean;
+    dropOverItemsCallback: (source: GridsterItem, target: GridsterItem, grid?: GridsterComponentInterface) => void;
+}
+export interface Resizable extends DragBase {
+    handles: {
+        s: boolean;
+        e: boolean;
+        n: boolean;
+        w: boolean;
+        se: boolean;
+        ne: boolean;
+        sw: boolean;
+        nw: boolean;
+    };
+}
+export interface PushDirections {
+    north: boolean;
+    east: boolean;
+    south: boolean;
+    west: boolean;
+}

package/gridster/lib/gridsterDraggable.service.d.ts

@@ -0,0 +1,68 @@
+import { NgZone } from '@angular/core';
+import { GridsterComponentInterface } from './gridster.interface';
+import { GridsterItemComponentInterface } from './gridsterItem.interface';
+import { GridsterPush } from './gridsterPush.service';
+import { GridsterSwap } from './gridsterSwap.service';
+export declare class GridsterDraggable {
+    private zone;
+    gridsterItem: GridsterItemComponentInterface;
+    gridster: GridsterComponentInterface;
+    lastMouse: {
+        clientX: number;
+        clientY: number;
+    };
+    offsetLeft: number;
+    offsetTop: number;
+    margin: number;
+    outerMarginTop: number | null;
+    outerMarginRight: number | null;
+    outerMarginBottom: number | null;
+    outerMarginLeft: number | null;
+    diffTop: number;
+    diffLeft: number;
+    originalClientX: number;
+    originalClientY: number;
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+    positionX: number;
+    positionY: number;
+    positionXBackup: number;
+    positionYBackup: number;
+    enabled: boolean;
+    mousemove: () => void;
+    mouseup: () => void;
+    mouseleave: () => void;
+    cancelOnBlur: () => void;
+    touchmove: () => void;
+    touchend: () => void;
+    touchcancel: () => void;
+    mousedown: () => void;
+    touchstart: () => void;
+    push: GridsterPush;
+    swap: GridsterSwap;
+    path: Array<{
+        x: number;
+        y: number;
+    }>;
+    collision: GridsterItemComponentInterface | boolean;
+    constructor(gridsterItem: GridsterItemComponentInterface, gridster: GridsterComponentInterface, zone: NgZone);
+    destroy(): void;
+    dragStart(e: MouseEvent): void;
+    dragMove: (e: MouseEvent) => void;
+    calculateItemPositionFromMousePosition: (e: MouseEvent) => void;
+    calculateItemPositionWithScale(e: MouseEvent, scale: number): void;
+    calculateItemPositionWithoutScale(e: MouseEvent): void;
+    dragStop: (e: MouseEvent) => void;
+    cancelDrag: () => void;
+    makeDrag: () => void;
+    calculateItemPosition(): void;
+    toggle(): void;
+    dragStartDelay: (e: MouseEvent) => void;
+    /**
+     * Returns the list of directions for given mouse event
+     * @param e Mouse event
+     * */
+    private getDirections;
+}

package/gridster/lib/gridsterEmptyCell.service.d.ts

@@ -0,0 +1,31 @@
+import { GridsterComponentInterface } from './gridster.interface';
+import { GridsterItem } from './gridsterItem.interface';
+export declare class GridsterEmptyCell {
+    private gridster;
+    initialItem: GridsterItem | null;
+    removeEmptyCellClickListenerFn: (() => void) | null;
+    removeEmptyCellTouchendListenerFn: (() => void) | null;
+    removeEmptyCellContextMenuListenerFn: (() => void) | null;
+    removeEmptyCellDropListenerFn: (() => void) | null;
+    removeEmptyCellMousedownListenerFn: (() => void) | null;
+    removeEmptyCellTouchstartListenerFn: (() => void) | null;
+    removeWindowMousemoveListenerFn: () => void;
+    removeWindowTouchmoveListenerFn: () => void;
+    removeWindowMouseupListenerFn: () => void;
+    removeWindowTouchendListenerFn: () => void;
+    removeEmptyCellDragoverListenerFn: (() => void) | null;
+    removeDocumentDragendListenerFn: (() => void) | null;
+    constructor(gridster: GridsterComponentInterface);
+    destroy(): void;
+    updateOptions(): void;
+    emptyCellClickCb: (e: MouseEvent) => void;
+    emptyCellContextMenuCb: (e: MouseEvent) => void;
+    emptyCellDragDrop: (e: DragEvent) => void;
+    emptyCellDragOver: (e: DragEvent) => void;
+    emptyCellMouseDown: (e: MouseEvent) => void;
+    emptyCellMouseMove: (e: MouseEvent) => void;
+    emptyCellMouseUp: (e: MouseEvent) => void;
+    getPixelsX(e: MouseEvent, rect: ClientRect): number;
+    getPixelsY(e: MouseEvent, rect: ClientRect): number;
+    getValidItemFromEvent(e: MouseEvent, oldItem?: GridsterItem | null): GridsterItem | undefined;
+}

package/gridster/lib/gridsterItem.component.d.ts

@@ -0,0 +1,61 @@
+import { ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, OnInit, Renderer2, SimpleChanges } from '@angular/core';
+import { GridsterComponent } from './gridster.component';
+import { GridsterDraggable } from './gridsterDraggable.service';
+import { GridsterItem, GridsterItemComponentInterface } from './gridsterItem.interface';
+import { GridsterResizable } from './gridsterResizable.service';
+import * as i0 from "@angular/core";
+export declare class GridsterItemComponent implements OnInit, OnDestroy, OnChanges, GridsterItemComponentInterface {
+    renderer: Renderer2;
+    private zone;
+    item: GridsterItem;
+    itemInit: EventEmitter<{
+        item: GridsterItem;
+        itemComponent: GridsterItemComponentInterface;
+    }>;
+    itemChange: EventEmitter<{
+        item: GridsterItem;
+        itemComponent: GridsterItemComponentInterface;
+    }>;
+    itemResize: EventEmitter<{
+        item: GridsterItem;
+        itemComponent: GridsterItemComponentInterface;
+    }>;
+    $item: GridsterItem;
+    el: HTMLElement;
+    gridster: GridsterComponent;
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    drag: GridsterDraggable;
+    resize: GridsterResizable;
+    notPlaced: boolean;
+    init: boolean;
+    get zIndex(): number;
+    constructor(el: ElementRef, gridster: GridsterComponent, renderer: Renderer2, zone: NgZone);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    updateOptions(): void;
+    ngOnDestroy(): void;
+    setSize(): void;
+    updateItemSize(): void;
+    itemChanged(): void;
+    checkItemChanges(newValue: GridsterItem, oldValue: GridsterItem): void;
+    canBeDragged(): boolean;
+    canBeResized(): boolean;
+    getResizableHandles(): {
+        s: boolean;
+        e: boolean;
+        n: boolean;
+        w: boolean;
+        se: boolean;
+        ne: boolean;
+        sw: boolean;
+        nw: boolean;
+    };
+    bringToFront(offset: number): void;
+    sendToBack(offset: number): void;
+    private getLayerIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridsterItemComponent, "gridster-item", never, { "item": { "alias": "item"; "required": false; }; }, { "itemInit": "itemInit"; "itemChange": "itemChange"; "itemResize": "itemResize"; }, never, ["*"], true, never>;
+}

package/gridster/lib/gridsterItem.interface.d.ts

@@ -0,0 +1,64 @@
+import { GridsterDraggable } from './gridsterDraggable.service';
+import { Renderer2 } from '@angular/core';
+import { GridsterResizable } from './gridsterResizable.service';
+import { GridsterComponentInterface } from './gridster.interface';
+export declare abstract class GridsterItemComponentInterface {
+    item: GridsterItem;
+    $item: GridsterItem;
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    drag: GridsterDraggable;
+    resize: GridsterResizable;
+    notPlaced: boolean;
+    updateOptions: () => void;
+    itemChanged: () => void;
+    setSize: () => void;
+    checkItemChanges: (newValue: GridsterItem, oldValue: GridsterItem) => void;
+    canBeDragged: () => boolean;
+    canBeResized: () => boolean;
+    getResizableHandles: () => {
+        s: boolean;
+        e: boolean;
+        n: boolean;
+        w: boolean;
+        se: boolean;
+        ne: boolean;
+        sw: boolean;
+        nw: boolean;
+    };
+    bringToFront: (offset: number) => void;
+    sendToBack: (v: number) => void;
+    el: HTMLElement;
+    gridster: GridsterComponentInterface;
+    renderer: Renderer2;
+}
+export interface GridsterItem {
+    x: number;
+    y: number;
+    rows: number;
+    cols: number;
+    layerIndex?: number;
+    initCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
+    dragEnabled?: boolean;
+    resizeEnabled?: boolean;
+    resizableHandles?: {
+        s?: boolean;
+        e?: boolean;
+        n?: boolean;
+        w?: boolean;
+        se?: boolean;
+        ne?: boolean;
+        sw?: boolean;
+        nw?: boolean;
+    };
+    compactEnabled?: boolean;
+    maxItemRows?: number;
+    minItemRows?: number;
+    maxItemCols?: number;
+    minItemCols?: number;
+    minItemArea?: number;
+    maxItemArea?: number;
+    [propName: string]: any;
+}

package/gridster/lib/gridsterPreview.component.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import { GridsterItem } from './gridsterItem.interface';
+import { GridsterRenderer } from './gridsterRenderer.service';
+import * as i0 from "@angular/core";
+export declare class GridsterPreviewComponent implements OnInit, OnDestroy {
+    private renderer;
+    previewStyle$: EventEmitter<GridsterItem | null>;
+    gridRenderer: GridsterRenderer;
+    private el;
+    private sub;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private previewStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterPreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GridsterPreviewComponent, "gridster-preview", never, { "previewStyle$": { "alias": "previewStyle$"; "required": false; }; "gridRenderer": { "alias": "gridRenderer"; "required": false; }; }, {}, never, never, true, never>;
+}