@taskctrl/canvas-timeline 0.8.0 → 0.8.1

package/dist/core/HitTest.d.ts

@@ -19,3 +19,18 @@ export declare function resolveCanResize(item: Item, globalCanResize: false | 'l
  * falling through to the global value.
  */
 export declare function resolveCanMove(item: Item, globalCanMove: boolean): boolean;
+/**
+ * Decide which interaction (if any) a pointer-down at `edge` should start for
+ * `item`, given the timeline-wide `canResize`/`canMove` props. Returns `null`
+ * when nothing is permitted — the caller then starts no interaction (no ghost)
+ * and shows no affordance (default cursor). Centralising this keeps the cursor
+ * and the interaction decision in lockstep.
+ *
+ * An item explicitly resize-locked per-item (`item.canResize === false`) has
+ * inert edges: grabbing an edge returns `null` rather than falling through to a
+ * move, so a user trying to resize a locked item sees no UI. This is scoped to
+ * the *explicit* per-item override — an item inheriting a global `canResize:
+ * false` (field undefined) keeps the move-only behaviour where the whole item,
+ * edges included, is draggable.
+ */
+export declare function resolveInteractionMode(item: Item, edge: 'left' | 'right' | 'body', globalCanResize: false | 'left' | 'right' | 'both', globalCanMove: boolean): 'move' | 'resize-left' | 'resize-right' | null;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { Group, Item, ItemBounds, ItemState, DrawHelpers, CanvasItemRenderer, CanvasGroupItemRenderer, DayStyle, RowStyle, Dependency, TimeRangeHighlight, TimelineTheme, MarkerConfig, CanvasTimelineProps, CanvasTimelineRef, CaptureOptions, } from './types';
+export type { Group, Item, ItemBounds, ItemState, DrawHelpers, CanvasItemRenderer, CanvasGroupItemRenderer, DayStyle, RowStyle, Dependency, TimeRangeHighlight, TimelineTheme, MarkerConfig, InteractionInfo, CanvasTimelineProps, CanvasTimelineRef, CaptureOptions, } from './types';
 export { DEFAULT_THEME } from './types';
 export { CanvasTimeline } from './CanvasTimeline';
 export { HierarchyEngine } from './core/HierarchyEngine';

package/dist/interaction/interactionInfo.d.ts

@@ -0,0 +1,26 @@
+import type { Item, InteractionInfo } from '../types';
+import type { ViewState } from '../core/ViewState';
+import type { IntervalTree } from '../core/IntervalTree';
+import type { HierarchyEngine } from '../core/HierarchyEngine';
+import type { InteractionState } from './InteractionHandler';
+/** The subset of props the snap helpers need. */
+export interface SnapDeps {
+    canvasWidth: number;
+    dragSnap: number;
+    intervalTree: IntervalTree<Item>;
+    hierarchyEngine: HierarchyEngine;
+}
+/** Snapped new start time for a move, matching the pointer-up commit path:
+ *  item-edge snap (start edge first, then end edge) with grid snap as fallback. */
+export declare function snappedMoveStart(state: InteractionState, vs: ViewState, p: SnapDeps): number;
+/** Snapped edge time for a resize, matching the pointer-up commit path: item-edge
+ *  snap with grid-snap fallback, then hierarchy resize constraints. */
+export declare function snappedResizeEdge(state: InteractionState, vs: ViewState, p: SnapDeps): {
+    edge: 'left' | 'right';
+    time: number;
+};
+/** Build the public InteractionInfo payload for the current drag/resize state. */
+export declare function buildInteractionInfo(state: InteractionState, vs: ViewState, p: SnapDeps, pointer: {
+    x: number;
+    y: number;
+}): InteractionInfo;

package/dist/types.d.ts

@@ -107,6 +107,28 @@ export interface MarkerConfig {
     width: number;
     label?: string;
 }
+/** Live state of an in-progress drag/resize, emitted via `onInteractionUpdate`.
+ *  All times are the snapped values that will commit on drop (item-edge snap +
+ *  grid snap, plus hierarchy resize constraints) — i.e. where the item will
+ *  actually land, matching the snap guide. The consumer-supplied
+ *  `moveResizeValidator` is NOT applied here (it may run per frame). */
+export interface InteractionInfo {
+    itemId: number;
+    mode: 'move' | 'resize-left' | 'resize-right';
+    /** Set for resize interactions; which edge is being dragged. */
+    edge?: 'left' | 'right';
+    /** The headline time to display: the new start for `move`/`resize-left`, the
+     *  new end for `resize-right`. */
+    time: number;
+    /** The item's snapped start time during this interaction. */
+    startTime: number;
+    /** The item's snapped end time during this interaction. */
+    endTime: number;
+    /** Pointer position in viewport coordinates (clientX/clientY), for
+     *  positioning a `position: fixed` tooltip without further math. */
+    pointerX: number;
+    pointerY: number;
+}
 export interface CanvasTimelineProps {
     groups: Group[];
     items: Item[];
@@ -148,6 +170,11 @@ export interface CanvasTimelineProps {
     /** Validate and optionally constrain move/resize. Return the (possibly modified) time. */
     moveResizeValidator?: (action: 'move' | 'resize', itemId: number, time: number, edge?: 'left' | 'right') => number;
     onItemHover?: (itemId: number | null, e: PointerEvent) => void;
+    /** Fires once per animation frame during an active drag/resize, then once with
+     *  `null` when it ends. Intended for a live "current time" tooltip. This is a
+     *  hot path: do NOT call setState here — mutate a ref'd DOM node's text/transform
+     *  directly so neither the library nor your app re-renders per frame. */
+    onInteractionUpdate?: (info: InteractionInfo | null) => void;
     onCanvasDoubleClick?: (groupId: number, time: number) => void;
     onCanvasContextMenu?: (groupId: number, time: number, e: PointerEvent) => void;
     onTimeChange?: (start: number, end: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taskctrl/canvas-timeline",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "High-performance canvas-based timeline component for React",
   "scripts": {
     "build": "rimraf ./dist && tsc && vite build",