react-timelane 0.0.2 → 0.0.3

package/dist/components/Timelane.d.ts

@@ -1,5 +1,7 @@
 import { PropsWithChildren } from 'react';
-import { CoreSwimlane, TimelaneBody, TimelaneLayout } from '..';
+import { TimelaneLane } from './TimelaneLane/TimelaneLane';
+import { TimelaneBody } from './TimelaneBody';
+import { TimelaneLayout } from './TimelaneLayout/TimelaneLayout';
 import { TimelaneHeader } from './TimelaneHeader/TimelaneHeader';
 import { TimelaneBackground } from './TimelaneBackground';
 import { TimelaneAside } from './TimelaneAside';
@@ -10,6 +12,6 @@ export declare namespace Timelane {
     var Body: typeof TimelaneBody;
     var Background: typeof TimelaneBackground;
     var Aside: typeof TimelaneAside;
-    var Lane: typeof CoreSwimlane;
+    var Lane: typeof TimelaneLane;
     var Layout: typeof TimelaneLayout;
 }

package/dist/components/TimelaneAside.d.ts

@@ -1,13 +1,13 @@
 import { MouseEvent, ReactElement } from 'react';
-import { SwimlaneT } from '../types';
+import { Lane } from '../types';
 interface TimelaneAsideProps {
-    lanes: SwimlaneT[];
-    focusedLane?: SwimlaneT | null;
-    setFocusedLane?: (lane: SwimlaneT | null) => void;
-    onLaneHeaderClick?: (lane: SwimlaneT, e: MouseEvent) => void;
-    onLaneHeaderDoubleClick?: (lane: SwimlaneT, e: MouseEvent) => void;
-    onLaneHeaderContextMenu?: (lane: SwimlaneT, e: MouseEvent) => void;
-    renderLaneHeader?: (lane: SwimlaneT) => ReactElement;
+    lanes: Lane[];
+    focusedLane?: Lane | null;
+    setFocusedLane?: (lane: Lane | null) => void;
+    onLaneHeaderClick?: (lane: Lane, e: MouseEvent) => void;
+    onLaneHeaderDoubleClick?: (lane: Lane, e: MouseEvent) => void;
+    onLaneHeaderContextMenu?: (lane: Lane, e: MouseEvent) => void;
+    renderLaneHeader?: (lane: Lane) => ReactElement;
 }
 export declare function TimelaneAside({ lanes, focusedLane, setFocusedLane, onLaneHeaderClick, onLaneHeaderDoubleClick, onLaneHeaderContextMenu, renderLaneHeader, }: TimelaneAsideProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/TimelaneBodyInner.d.ts

@@ -1,13 +1,13 @@
 import { MouseEvent, ReactElement } from 'react';
-import { AvailableSpace, CoreItem, SwimlaneT } from '../types';
+import { AvailableSpace, Item, Lane } from '../types';
 interface TimelaneBodyInnerProps<T> {
-    lanes: SwimlaneT[];
-    items: CoreItem<T>[];
-    renderItem?: (item: CoreItem<T>, isDragged: boolean) => ReactElement;
-    onItemUpdate?: (item: CoreItem<T>) => void;
-    onLaneClick?: (lane: SwimlaneT, when: Date, availableSpace: AvailableSpace | null, e: MouseEvent) => void;
-    onLaneDoubleClick?: (lane: SwimlaneT, when: Date, availableSpace: AvailableSpace | null, e: MouseEvent) => void;
-    onLaneContextMenu?: (lane: SwimlaneT, when: Date, e: MouseEvent) => void;
+    lanes: Lane[];
+    items: Item<T>[];
+    renderItem?: (item: Item<T>, isDragged: boolean) => ReactElement;
+    onItemUpdate?: (item: Item<T>) => void;
+    onLaneClick?: (lane: Lane, when: Date, availableSpace: AvailableSpace | null, e: MouseEvent) => void;
+    onLaneDoubleClick?: (lane: Lane, when: Date, availableSpace: AvailableSpace | null, e: MouseEvent) => void;
+    onLaneContextMenu?: (lane: Lane, when: Date, e: MouseEvent) => void;
 }
 /**
  * @deprecated The component should not be used

package/dist/components/{core/CoreItem → TimelaneItem}/DragResizeComponent.d.ts

@@ -1,7 +1,7 @@
 import { PropsWithChildren } from 'react';
-import { Position, Rectangle, Dimensions, CoreItem } from '../../../types';
+import { Position, Rectangle, Dimensions, Item } from '../../types';
 interface DragResizeComponentProps<T> {
-    item: CoreItem<T>;
+    item: Item<T>;
     rectangle: Rectangle;
     boundingRectangle: Dimensions;
     onDragStart: (grabPosition: Position, relativeGrabPosition: Position) => void;

package/dist/components/TimelaneItem/TimelaneItem.d.ts

@@ -0,0 +1,14 @@
+import { PropsWithChildren } from 'react';
+import { Item, Position, Lane, TimelaneSettings } from '../../types';
+interface TimelaneItemProps<T> {
+    item: Item<T>;
+    lane: Lane;
+    settings: TimelaneSettings;
+    onDragStart: (grabPosition: Position, relativeGrabPosition: Position) => void;
+    onDrop: () => void;
+    onDrag: () => void;
+    onUpdate: (updatedItem: Item<T>) => void;
+    onResizeStart: () => void;
+}
+export default function TimelaneItem<T>({ lane, item, settings, children, onDragStart, onDrag, onDrop, onUpdate, onResizeStart, }: PropsWithChildren<TimelaneItemProps<T>>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/{core/CoreSwimlane → TimelaneLane}/AvailableSpaceIndicator.d.ts

@@ -1,11 +1,11 @@
 import { PropsWithChildren } from 'react';
-import { CoreItem, Pixels, SwimlaneT, TimeRange } from '../../../types';
+import { Item, Pixels, Lane, TimeRange } from '../../types';
 interface AvailableSpaceIndicatorProps<T> {
     pixels: Pixels;
     range: TimeRange;
-    swimlane: SwimlaneT;
+    swimlane: Lane;
     debug: boolean;
-    items: CoreItem<T>[];
+    items: Item<T>[];
 }
 /**
  * A component that displays the available space at the mouse cursor position.

package/dist/components/{core/CoreSwimlane → TimelaneLane}/DropTarget.d.ts

@@ -1,5 +1,5 @@
 import { PropsWithChildren } from 'react';
-import { GrabInfo, Position } from '../../../types';
+import { GrabInfo, Position } from '../../types';
 interface DropTargetProps {
     onDragStart?: (mousePos: Position, grabInfo: GrabInfo, data: any) => void;
     onDrag?: (mousePos: Position, grabInfo: GrabInfo, data: any) => void;

package/dist/components/{core/CoreSwimlane → TimelaneLane}/OverlapIndicator.d.ts

@@ -1,4 +1,4 @@
-import { Rectangle } from '../../../types';
+import { Rectangle } from '../../types';
 interface OverlapIndicatorProps {
     overlap: Rectangle;
 }

package/dist/components/{core/CoreSwimlane/CoreSwimlane.d.ts → TimelaneLane/TimelaneLane.d.ts}

@@ -1,16 +1,16 @@
 import { MouseEvent, ReactElement } from 'react';
-import { AvailableSpace, CoreItem, SwimlaneT } from '../../../types';
-interface CoreSwimlaneProps<T> {
-    swimlane: SwimlaneT;
-    items: CoreItem<T>[];
+import { AvailableSpace, Item, Lane } from '../../types';
+interface TimelaneLaneProps<T> {
+    swimlane: Lane;
+    items: Item<T>[];
     focused?: boolean;
-    onItemUpdate?: (item: CoreItem<T>) => void;
+    onItemUpdate?: (item: Item<T>) => void;
     onMouseUp?: (e: MouseEvent) => void;
     onClick?: (when: Date, availableSpace: AvailableSpace | null, e: MouseEvent) => void;
     onDoubleClick?: (when: Date, availableSpace: AvailableSpace | null, e: MouseEvent) => void;
     onContextMenu?: (when: Date, e: MouseEvent) => void;
-    renderItem?: (item: CoreItem<T>, isDragged: boolean) => ReactElement;
+    renderItem?: (item: Item<T>, isDragged: boolean) => ReactElement;
     onResizeStart?: (data: T) => void;
 }
-export declare function CoreSwimlane<T>({ swimlane, items, focused, onItemUpdate, onMouseUp, onClick, onDoubleClick, onContextMenu, renderItem, onResizeStart, }: CoreSwimlaneProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function TimelaneLane<T>({ swimlane, items, focused, onItemUpdate, onMouseUp, onClick, onDoubleClick, onContextMenu, renderItem, onResizeStart, }: TimelaneLaneProps<T>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/TimelaneSettingsContext.d.ts

@@ -1,5 +1,5 @@
 import { Dispatch, SetStateAction } from 'react';
-import { TimelaneSettings } from '../types/TimelaneSettings';
+import { TimelaneSettings } from '../types/';
 export interface TimelaneContextOuter {
     settings: TimelaneSettings;
     setSettings: Dispatch<SetStateAction<TimelaneSettings>>;

package/dist/components/TimelaneWrapper.d.ts

@@ -1,8 +1,8 @@
 import { PropsWithChildren } from 'react';
-import { SwimlaneT } from '../types';
+import { Lane } from '../types';
 interface TimelaneWrapperProps {
     focusedDay?: Date | null;
-    focusedSwimlane?: SwimlaneT | null;
+    focusedSwimlane?: Lane | null;
     start?: Date;
     end?: Date;
     pixelsPerDay?: number;

package/dist/components/utils.d.ts

@@ -0,0 +1,27 @@
+import { DragLocationHistory, ElementDragPayload } from '@atlaskit/pragmatic-drag-and-drop/dist/types/internal-types';
+import { Item, Dimensions, Pixels, Position, Rectangle, Lane, TimeRange, AvailableSpace, GrabInfo, Grid } from '../types';
+export declare function getDropTargetDimensions(lane: Lane, pixels: Pixels, range: TimeRange): Dimensions;
+export declare function getDropTargetHeight(lane: Lane, pixels: Pixels): number;
+export declare function getDropTargetWidth(lane: Lane, pixels: Pixels, range: TimeRange): number;
+export declare function getItemRectangle<T>(item: Item<T>, lane: Lane, range: TimeRange, pixels: Pixels): Rectangle;
+export declare function getItemDimensions<T>(item: Item<T>, lane: Lane, pixels: Pixels): Dimensions;
+export declare function dateToPixel(date: Date, start: Date, pixels: Pixels): number;
+export declare function offsetToPixel(offset: number, capacity: number, pixels: Pixels): number;
+export declare function getItemPosition<T>(item: Item<T>, lane: Lane, start: Date, pixels: Pixels): Position;
+export declare function getGrabPosition(source: ElementDragPayload, location: DragLocationHistory): {
+    absolute: Position;
+    relative: Position;
+};
+export declare function getUpdatedItem<T>(oldItem: Item<T>, swimlane: Lane, dropPreviewRect: Rectangle, pixels: Pixels, range: TimeRange): Item<T>;
+export declare function getDropPreviewRectangle<S, T>(swimlane: Lane, items: Item<T>[], item: Item<S>, mousePosition: Position | null, grabInfo: GrabInfo, pixels: Pixels, grid: Grid, range: TimeRange, allowOverlaps: boolean): Rectangle | null;
+/**
+ * Returns true if two rectangles (l1, r1) and (l2, r2) overlap
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function doOverlap(a: Rectangle, b: Rectangle): boolean;
+export declare function getOverlap(a: Rectangle, b: Rectangle): Rectangle | null;
+export declare function itemsDoOverlap<T>(a: Item<T>, b: Item<T>): boolean;
+export declare function isWithinTargetDimensions(item: Rectangle, targetDimensions: Dimensions): boolean;
+export declare function getAvailableSpace<T>(clickedDate: Date, clickedOffset: number, swimlane: Lane, items: Item<T>[], range: TimeRange): AvailableSpace | null;

package/dist/hooks/useScroll.d.ts

@@ -1,10 +1,10 @@
-import { ItemId, SwimlaneId } from '../types';
+import { ItemId, LaneId } from '../types';
 export declare const useScroll: () => {
     scrollTo: (destination: {
         horz?: Date;
-        vert?: SwimlaneId;
+        vert?: LaneId;
     } | ItemId) => void;
     scrollToDate: (date: Date) => void;
     scrollToItem: (itemId: ItemId) => void;
-    scrollToLane: (laneId: SwimlaneId) => void;
+    scrollToLane: (laneId: LaneId) => void;
 };

package/dist/index.d.ts

@@ -1,13 +1,12 @@
-export { TimelaneLayout } from './components/layout/TimelaneLayout';
+export { TimelaneLayout } from './components/TimelaneLayout/TimelaneLayout';
 export { TimelaneAside } from './components/TimelaneAside';
 export { TimelaneBackground } from './components/TimelaneBackground';
-export { CoreSwimlane } from './components/core/CoreSwimlane/CoreSwimlane';
+export { TimelaneLane } from './components/TimelaneLane/TimelaneLane';
 export { TimelaneBody } from './components/TimelaneBody';
 export { Timelane } from './components/Timelane';
 export { TimelaneSettingsProvider } from './components/TimelaneSettingsProvider';
 export * from './components/TimelaneHeader';
 export * from './types';
-export * from './components/core/utils';
-export * from './components/core/CoreSwimlane/utils';
+export * from './components/utils';
 export { useScroll } from './hooks/useScroll';
 export { useTimelaneContext } from './hooks/useTimelaneContext';