@prefecthq/graphs 1.0.8 → 2.0.2

package/dist/types/src/FlowRunTimeline.vue.d.ts

@@ -1,111 +1,13 @@
-import { GraphTimelineNode, TimelineThemeOptions, FormatDateFns, TimelineNodesLayoutOptions, CenterViewportOptions, ExpandedSubNodes, NodeSelectionEvent, TimelineVisibleDateRange } from './models';
-declare const _default: {
-    new (...args: any[]): {
-        $: import("vue").ComponentInternalInstance;
-        $data: {};
-        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
-            graphData: GraphTimelineNode[];
-            isRunning?: boolean | undefined;
-            theme?: TimelineThemeOptions | undefined;
-            formatDateFns?: Partial<FormatDateFns> | undefined;
-            selectedNodeId?: string | null | undefined;
-            layout?: TimelineNodesLayoutOptions | undefined;
-            hideEdges?: boolean | undefined;
-            subNodeLabels?: Map<string, string> | undefined;
-            expandedSubNodes?: ExpandedSubNodes<Record<string, unknown>> | undefined;
-            visibleDateRange?: TimelineVisibleDateRange | undefined;
-        }>>> & {
-            onSelection?: ((value: NodeSelectionEvent | null) => any) | undefined;
-            onSubNodeToggle?: ((value: string) => any) | undefined;
-            "onUpdate:visibleDateRange"?: ((value: TimelineVisibleDateRange | undefined) => any) | undefined;
-        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
-        $attrs: {
-            [x: string]: unknown;
-        };
-        $refs: {
-            [x: string]: unknown;
-        };
-        $slots: Readonly<{
-            [name: string]: import("vue").Slot | undefined;
-        }>;
-        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
-        $emit: ((event: "selection", value: NodeSelectionEvent | null) => void) & ((event: "subNodeToggle", value: string) => void) & ((event: "update:visibleDateRange", value: TimelineVisibleDateRange | undefined) => void);
-        $el: any;
-        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
-            graphData: GraphTimelineNode[];
-            isRunning?: boolean | undefined;
-            theme?: TimelineThemeOptions | undefined;
-            formatDateFns?: Partial<FormatDateFns> | undefined;
-            selectedNodeId?: string | null | undefined;
-            layout?: TimelineNodesLayoutOptions | undefined;
-            hideEdges?: boolean | undefined;
-            subNodeLabels?: Map<string, string> | undefined;
-            expandedSubNodes?: ExpandedSubNodes<Record<string, unknown>> | undefined;
-            visibleDateRange?: TimelineVisibleDateRange | undefined;
-        }>>> & {
-            onSelection?: ((value: NodeSelectionEvent | null) => any) | undefined;
-            onSubNodeToggle?: ((value: string) => any) | undefined;
-            "onUpdate:visibleDateRange"?: ((value: TimelineVisibleDateRange | undefined) => any) | undefined;
-        }, {
-            centerViewport: ({ skipAnimation }?: CenterViewportOptions) => void;
-            moveViewportCenter: ({ xOffset, yOffset }: {
-                xOffset: number;
-                yOffset: number;
-            }) => void;
-        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-            selection: (value: NodeSelectionEvent | null) => void;
-        } & {
-            subNodeToggle: (value: string) => void;
-        } & {
-            "update:visibleDateRange": (value: TimelineVisibleDateRange | undefined) => void;
-        }, string, {}, {}, string> & {
-            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
-            created?: ((() => void) | (() => void)[]) | undefined;
-            beforeMount?: ((() => void) | (() => void)[]) | undefined;
-            mounted?: ((() => void) | (() => void)[]) | undefined;
-            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
-            updated?: ((() => void) | (() => void)[]) | undefined;
-            activated?: ((() => void) | (() => void)[]) | undefined;
-            deactivated?: ((() => void) | (() => void)[]) | undefined;
-            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
-            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
-            destroyed?: ((() => void) | (() => void)[]) | undefined;
-            unmounted?: ((() => void) | (() => void)[]) | undefined;
-            renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
-            renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
-            errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
-        };
-        $forceUpdate: () => void;
-        $nextTick: typeof import("vue").nextTick;
-        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
-    } & Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
-        graphData: GraphTimelineNode[];
-        isRunning?: boolean | undefined;
-        theme?: TimelineThemeOptions | undefined;
-        formatDateFns?: Partial<FormatDateFns> | undefined;
-        selectedNodeId?: string | null | undefined;
-        layout?: TimelineNodesLayoutOptions | undefined;
-        hideEdges?: boolean | undefined;
-        subNodeLabels?: Map<string, string> | undefined;
-        expandedSubNodes?: ExpandedSubNodes<Record<string, unknown>> | undefined;
-        visibleDateRange?: TimelineVisibleDateRange | undefined;
-    }>>> & {
-        onSelection?: ((value: NodeSelectionEvent | null) => any) | undefined;
-        onSubNodeToggle?: ((value: string) => any) | undefined;
-        "onUpdate:visibleDateRange"?: ((value: TimelineVisibleDateRange | undefined) => any) | undefined;
-    } & import("vue").ShallowUnwrapRef<{
-        centerViewport: ({ skipAnimation }?: CenterViewportOptions) => void;
-        moveViewportCenter: ({ xOffset, yOffset }: {
-            xOffset: number;
-            yOffset: number;
-        }) => void;
-    }> & {} & import("vue").ComponentCustomProperties & {};
-    __isFragment?: undefined;
-    __isTeleport?: undefined;
-    __isSuspense?: undefined;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
-    graphData: GraphTimelineNode[];
+import { TimelineThemeOptions, FormatDateFns, TimelineNodesLayoutOptions, CenterViewportOptions, ExpandedSubNodes, NodeSelectionEvent, TimelineVisibleDateRange } from './models';
+import { TimelineData } from './types/timeline';
+declare function centerViewport({ skipAnimation }?: CenterViewportOptions): void;
+type MoveViewportCenterOptions = {
+    xOffset: number;
+    yOffset: number;
+};
+declare function moveViewportCenter({ xOffset, yOffset }: MoveViewportCenterOptions): void;
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    data: TimelineData;
     isRunning?: boolean | undefined;
     theme?: TimelineThemeOptions | undefined;
     formatDateFns?: Partial<FormatDateFns> | undefined;
@@ -113,25 +15,31 @@ declare const _default: {
     layout?: TimelineNodesLayoutOptions | undefined;
     hideEdges?: boolean | undefined;
     subNodeLabels?: Map<string, string> | undefined;
-    expandedSubNodes?: ExpandedSubNodes<Record<string, unknown>> | undefined;
+    expandedSubNodes?: ExpandedSubNodes | undefined;
     visibleDateRange?: TimelineVisibleDateRange | undefined;
-}>>> & {
-    onSelection?: ((value: NodeSelectionEvent | null) => any) | undefined;
-    onSubNodeToggle?: ((value: string) => any) | undefined;
-    "onUpdate:visibleDateRange"?: ((value: TimelineVisibleDateRange | undefined) => any) | undefined;
-}, {
-    centerViewport: ({ skipAnimation }?: CenterViewportOptions) => void;
-    moveViewportCenter: ({ xOffset, yOffset }: {
-        xOffset: number;
-        yOffset: number;
-    }) => void;
+}>, {
+    centerViewport: typeof centerViewport;
+    moveViewportCenter: typeof moveViewportCenter;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     selection: (value: NodeSelectionEvent | null) => void;
-} & {
     subNodeToggle: (value: string) => void;
-} & {
     "update:visibleDateRange": (value: TimelineVisibleDateRange | undefined) => void;
-}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    data: TimelineData;
+    isRunning?: boolean | undefined;
+    theme?: TimelineThemeOptions | undefined;
+    formatDateFns?: Partial<FormatDateFns> | undefined;
+    selectedNodeId?: string | null | undefined;
+    layout?: TimelineNodesLayoutOptions | undefined;
+    hideEdges?: boolean | undefined;
+    subNodeLabels?: Map<string, string> | undefined;
+    expandedSubNodes?: ExpandedSubNodes | undefined;
+    visibleDateRange?: TimelineVisibleDateRange | undefined;
+}>>> & {
+    onSelection?: ((value: NodeSelectionEvent | null) => any) | undefined;
+    onSubNodeToggle?: ((value: string) => any) | undefined;
+    "onUpdate:visibleDateRange"?: ((value: TimelineVisibleDateRange | undefined) => any) | undefined;
+}, {}, {}>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
 type __VLS_TypePropsToRuntimeProps<T> = {

package/dist/types/src/containers/guide.d.ts

@@ -0,0 +1,29 @@
+import { Viewport } from 'pixi-viewport';
+import { Application, Container } from 'pixi.js';
+import { GraphState, ParsedThemeStyles } from '../models/FlowRunTimeline';
+export type GuideDateFormatter = (value: Date) => string;
+export type GuidesArgs = {
+    application: Application;
+    viewport: Viewport;
+    styles: ParsedThemeStyles;
+};
+export declare class Guide extends Container {
+    private readonly state;
+    private readonly viewportUpdated;
+    private format;
+    private date;
+    private line;
+    private label;
+    private readonly unwatch;
+    constructor(state: GraphState);
+    setDate(value: Date): void;
+    setFormat(value: GuideDateFormatter): void;
+    destroy(): void;
+    private readonly tick;
+    private createLine;
+    private createLabel;
+    private getPositionX;
+    private updateLineHeight;
+    private updatePosition;
+    private updateLabel;
+}

package/dist/types/src/containers/guides.d.ts

@@ -0,0 +1,26 @@
+import { Viewport } from 'pixi-viewport';
+import { Application, Container } from 'pixi.js';
+import { FormatDateFns, GraphState, ParsedThemeStyles } from '../models/FlowRunTimeline';
+export type GuidesArgs = {
+    application: Application;
+    viewport: Viewport;
+    styles: ParsedThemeStyles;
+    formatters: FormatDateFns;
+};
+export declare class Guides extends Container {
+    private readonly state;
+    private readonly guides;
+    private readonly viewportUpdated;
+    private readonly unwatch;
+    constructor(state: GraphState);
+    destroy(): void;
+    private readonly tick;
+    private getViewportDates;
+    private getTimeSpan;
+    private getFirstGuideDate;
+    private getGuideDates;
+    private getLabelFormat;
+    private updateGuides;
+    private updateOrCreateGuide;
+    private removeGuides;
+}

package/dist/types/src/index.d.ts

@@ -1,2 +1,3 @@
 export { default as FlowRunTimeline } from './FlowRunTimeline.vue';
+export * from './types';
 export * from './models';

package/dist/types/src/models/FlowRunTimeline.d.ts

@@ -2,20 +2,8 @@ import { Cull } from '@pixi-essentials/cull';
 import type { Viewport } from 'pixi-viewport';
 import type { Application, IBitmapTextStyle, TextStyle } from 'pixi.js';
 import type { ComputedRef } from 'vue';
-export type GraphTimelineNode = {
-    id: string;
-    label: string;
-    start?: Date;
-    end: Date | null;
-    state: string;
-    upstreamDependencies?: string[];
-    subFlowRunId?: string;
-};
-export declare function hasStartAndEndDates(node: GraphTimelineNode): node is GraphTimelineNode & {
-    start: Date;
-    end: Date;
-};
-export type InitTimelineScaleProps = {
+import { TimelineData, TimelineItem } from '../types/timeline';
+export type TimeScaleArgs = {
     minimumStartTime: number;
     graphXDomain: number;
     initialOverallTimeSpan: number;
@@ -32,21 +20,19 @@ export type NodeSelectionEvent = {
     type: NodeSelectionEventTypes;
 };
 export type ExpandedSubNodes<T extends Record<string, unknown> = Record<string, unknown>> = Map<string, {
-    data: GraphTimelineNode[] | ComputedRef<GraphTimelineNode[]>;
+    data: TimelineData | ComputedRef<TimelineData>;
 } & T>;
 export type NodeShoveDirection = 1 | -1;
-export type NodeLayoutWorkerProps = {
-    data: {
-        layoutSetting?: TimelineNodesLayoutOptions;
-        graphData?: string;
-        apxCharacterWidth?: number;
-        spacingMinimumNodeEdgeGap?: number;
-        timeScaleProps?: InitTimelineScaleProps;
-        centerViewportAfter?: boolean;
-    };
+export type NodeLayoutWorkerArgs = {
+    layoutSetting?: TimelineNodesLayoutOptions;
+    data?: TimelineData;
+    apxCharacterWidth?: number;
+    spacingMinimumNodeEdgeGap?: number;
+    timeScaleArgs?: TimeScaleArgs;
+    centerViewportAfter?: boolean;
 };
 export type NodeLayoutItem = {
-    position: number;
+    row: number;
     nextDependencyShove?: NodeShoveDirection;
     startX: number;
     endX: number;
@@ -68,10 +54,12 @@ export type GraphState = {
     viewport: Viewport;
     cull: Cull;
     cullScreen: () => void;
-    timeScaleProps: InitTimelineScaleProps;
+    timeScale: TimeScale;
+    timeScaleArgs: TimeScaleArgs;
     styleOptions: ComputedRef<ParsedThemeStyles>;
     styleNode: ComputedRef<NodeThemeFn>;
     layoutSetting: ComputedRef<TimelineNodesLayoutOptions>;
+    formatDateFns: ComputedRef<FormatDateFns>;
     isRunning: ComputedRef<boolean>;
     hideEdges: ComputedRef<boolean>;
     subNodeLabels: ComputedRef<Map<string, string>>;
@@ -82,7 +70,7 @@ export type GraphState = {
 };
 export type DateToX = (date: Date) => number;
 export type XToDate = (xPosition: number) => Date;
-export type TimelineScale = {
+export type TimeScale = {
     dateToX: DateToX;
     xToDate: XToDate;
 };
@@ -110,9 +98,9 @@ type NodeThemeOptions = {
     onFillSubNodeToggleHoverBg: string;
     onFillSubNodeToggleHoverBgAlpha: number;
 };
-export type NodeThemeFn = (node: GraphTimelineNode) => NodeThemeOptions;
+export type NodeThemeFn = (node: TimelineItem) => NodeThemeOptions;
 export declare const nodeThemeFnDefault: NodeThemeFn;
-type Sizing = `${string}px` | `${string}em` | `${string}rem`;
+export type Sizing = `${string}px` | `${string}em` | `${string}rem`;
 export type RGB = `rgb(${number}, ${number}, ${number})`;
 export type RGBA = `rgba(${number}, ${number}, ${number}, ${number})`;
 export type HSL = `hsl(${string | number}, ${number | string}, ${number | string})`;

package/dist/types/src/pixiFunctions/bitmapFonts.d.ts

@@ -1,4 +1,4 @@
 import { TextStyles, ParsedThemeStyles } from '../models';
 export declare function updateBitmapFonts(styles: ParsedThemeStyles): void;
-export declare const getBitmapFonts: (styles: ParsedThemeStyles) => Promise<TextStyles> | TextStyles;
+export declare const getBitmapFonts: (styles: ParsedThemeStyles) => Promise<TextStyles>;
 export declare const initBitmapFonts: (styles: ParsedThemeStyles) => void;

package/dist/types/src/pixiFunctions/index.d.ts

@@ -6,9 +6,8 @@ export * from './loadingIndicator';
 export * from './nodeSprites';
 export * from './roundedBorderRect';
 export * from './timelineEdge';
-export * from './timelineGuides';
 export * from './timelineNode';
 export * from './timelineNodes';
 export * from './timelinePlayhead';
-export * from './timelineScale';
+export * from './timeScale';
 export * from './subNodesToggle';

package/dist/types/src/pixiFunctions/nodeSprites.d.ts

@@ -8,7 +8,7 @@ type SimpleFillTextureProps = {
     pixiApp: Application;
     fill: number;
 };
-export declare function getSimpleFillTexture({ pixiApp, fill, }: SimpleFillTextureProps): Texture;
+export declare function getSimpleFillTexture({ pixiApp, fill: providedFill, }: SimpleFillTextureProps): Texture;
 type GetNodeBoxTexturesProps = {
     pixiApp: Application;
     fill: number;
@@ -16,7 +16,7 @@ type GetNodeBoxTexturesProps = {
     boxCapWidth: number;
     height: number;
 };
-export declare function getNodeBoxTextures({ pixiApp, fill, borderRadius, boxCapWidth, height, }: GetNodeBoxTexturesProps): BoxTextures;
+export declare function getNodeBoxTextures({ pixiApp, fill: providedFill, borderRadius, boxCapWidth, height, }: GetNodeBoxTexturesProps): BoxTextures;
 type GetArrowTextureProps = {
     pixiApp: Application;
     strokeColor: number;

package/dist/types/src/pixiFunctions/subNodesToggle.d.ts

@@ -1,8 +1,9 @@
 import { Container } from 'pixi.js';
-import { GraphState, GraphTimelineNode } from '../models';
+import { GraphState } from '../models';
+import { TimelineItem } from '../types/timeline';
 type SubNodesToggleProps = {
     graphState: GraphState;
-    nodeData: GraphTimelineNode;
+    nodeData: TimelineItem;
     size: number;
     floating?: boolean;
 };

package/dist/types/src/pixiFunctions/timeScale.d.ts

@@ -0,0 +1,2 @@
+import { TimeScale, TimeScaleArgs } from '../models';
+export declare const createTimeScale: ({ minimumStartTime, graphXDomain, initialOverallTimeSpan, }: TimeScaleArgs) => TimeScale;

package/dist/types/src/pixiFunctions/timelineEdge.d.ts

@@ -4,7 +4,7 @@ import { TimelineNode } from '../pixiFunctions';
 type TimelineEdgeProps = {
     sourceNode: TimelineNode;
     targetNode: TimelineNode;
-    graphState: GraphState;
+    state: GraphState;
 };
 export declare class TimelineEdge extends Container {
     private readonly sourceNode;
@@ -22,7 +22,7 @@ export declare class TimelineEdge extends Container {
     private readonly edge;
     private readonly arrow;
     private readonly unWatchers;
-    constructor({ sourceNode, targetNode, graphState, }: TimelineEdgeProps);
+    constructor({ sourceNode, targetNode, state, }: TimelineEdgeProps);
     private initCulling;
     private initWatchers;
     private assignBezierPositions;

package/dist/types/src/pixiFunctions/timelineNode.d.ts

@@ -1,6 +1,7 @@
 import { Container } from 'pixi.js';
 import { Ref } from 'vue';
-import { GraphTimelineNode, GraphState, NodeLayoutRow, NodesLayout } from '../models';
+import { GraphState, NodeLayoutRow, NodesLayout } from '../models';
+import { TimelineItem } from '../types/timeline';
 export declare const nodeClickEvents: {
     nodeDetails: string;
     subNodesToggle: string;
@@ -12,14 +13,14 @@ export declare const nodeAnimationDurations: {
 };
 export declare const timelineNodeBoxName = "box";
 type TimelineNodeProps = {
-    nodeData: GraphTimelineNode;
-    graphState: GraphState;
+    nodeData: TimelineItem;
+    state: GraphState;
     layout: Ref<NodesLayout>;
     layoutRows: Ref<NodeLayoutRow[]>;
 };
 export declare class TimelineNode extends Container {
-    nodeData: GraphTimelineNode;
-    private readonly graphState;
+    nodeData: TimelineItem;
+    private readonly state;
     private readonly layout;
     private readonly layoutRows;
     private currentState;
@@ -52,7 +53,7 @@ export declare class TimelineNode extends Container {
     private subNodesContentTicker;
     private isSelected;
     private selectedRing;
-    constructor({ nodeData, graphState, layout, layoutRows, }: TimelineNodeProps);
+    constructor({ nodeData, state, layout, layoutRows, }: TimelineNodeProps);
     private initWatchers;
     private drawSubNodesOutline;
     private initBox;
@@ -78,7 +79,7 @@ export declare class TimelineNode extends Container {
     /**
      * Update Functions
      */
-    update(newData?: GraphTimelineNode): void;
+    update(newData?: TimelineItem): void;
     private updatePosition;
     private updateIsRunningNode;
     private updateBoxWidth;

package/dist/types/src/pixiFunctions/timelineNodes.d.ts

@@ -1,19 +1,19 @@
 import { Container } from 'pixi.js';
-import { GraphTimelineNode, GraphState } from '../models';
+import { GraphState } from '../models';
 import { TimelineNode } from '../pixiFunctions';
+import { TimelineData } from '../types/timeline';
 export declare const timelineUpdateEvent = "timelineUpdateEvent";
 type TimelineNodesProps = {
     nodeContentContainerName?: string;
     isSubNodes?: boolean;
-    graphData: GraphTimelineNode[];
-    graphState: GraphState;
+    data: TimelineData;
+    state: GraphState;
 };
 export declare class TimelineNodes extends Container {
     private readonly layoutWorker;
     private readonly isSubNodes;
-    private graphData;
-    private readonly graphDataLookup;
-    private readonly graphState;
+    private data;
+    private readonly state;
     private readonly nodeContainer;
     readonly nodeRecords: Map<string, TimelineNode>;
     private readonly layout;
@@ -22,7 +22,7 @@ export declare class TimelineNodes extends Container {
     private readonly edgeRecords;
     private readonly unWatchers;
     private isSelectionPathHighlighted;
-    constructor({ nodeContentContainerName, isSubNodes, graphData, graphState, }: TimelineNodesProps);
+    constructor({ nodeContentContainerName, isSubNodes, data, state, }: TimelineNodesProps);
     private initWatchers;
     private initLayoutWorker;
     private initDeselectLayer;
@@ -32,7 +32,7 @@ export declare class TimelineNodes extends Container {
     /**
      * Update Functions
      */
-    update(newData: GraphTimelineNode[]): void;
+    update(newData: TimelineData): void;
     updateHideEdges(): void;
     private updateLayoutRows;
     updateLayoutSetting(): void;
@@ -46,10 +46,8 @@ export declare class TimelineNodes extends Container {
     /**
      * Utilities
      */
-    private setGraphDataLookup;
     private registerEmits;
     private emitNullSelection;
-    private getNodeData;
     getEarliestNodeStart(): Date | null;
     destroy(): void;
 }

package/dist/types/src/pixiFunctions/timelinePlayhead.d.ts

@@ -1,29 +1,14 @@
-import { Cull } from '@pixi-essentials/cull';
-import type { Viewport } from 'pixi-viewport';
-import { Application, Container } from 'pixi.js';
-import { ComputedRef } from 'vue';
-import { FormatDateFns, ParsedThemeStyles } from '../models';
-type TimelinePlayheadProps = {
-    viewportRef: Viewport;
-    appRef: Application;
-    cull: Cull;
-    formatDateFns: ComputedRef<FormatDateFns>;
-    styleOptions: ComputedRef<ParsedThemeStyles>;
-};
+import { Container } from 'pixi.js';
+import { GraphState } from '../models';
 export declare class TimelinePlayhead extends Container {
-    private readonly viewportRef;
-    private readonly appRef;
-    private readonly cull;
-    private readonly formatDateFns;
-    private readonly styleOptions;
+    private readonly state;
     private readonly unwatch;
     private readonly playhead;
     private label;
-    constructor({ viewportRef, appRef, cull, formatDateFns, styleOptions, }: TimelinePlayheadProps);
+    constructor(state: GraphState);
     private drawPlayhead;
     private drawTimeLabel;
     private getTimeLabelY;
     updatePosition(): void;
     destroy(): void;
 }
-export {};

package/dist/types/src/types/index.d.ts

@@ -0,0 +1 @@
+export * from './timeline';

package/dist/types/src/types/timeline.d.ts

@@ -0,0 +1,11 @@
+export type TimelineItem = {
+    id: string;
+    label: string;
+    state: string;
+    start: Date | null;
+    end: Date | null;
+    subflowRunId: string | null;
+    upstream: string[];
+    downstream: string[];
+};
+export type TimelineData = Map<string, TimelineItem>;

package/dist/types/src/utilities/index.d.ts

@@ -1,4 +1,5 @@
 export * from './map';
 export * from './math';
-export * from './time';
 export * from './style';
+export * from './time';
+export * from './zIndex';

package/dist/types/src/utilities/time.d.ts

@@ -1,3 +1,6 @@
+import { GuideDateFormatter } from '../containers/guide';
+import { FormatDateFns } from '../models/FlowRunTimeline';
+import { TimelineData } from '../types/timeline';
 export declare const intervals: {
     readonly year: 31536000;
     readonly day: 86400;
@@ -10,10 +13,7 @@ export declare function secondsToApproximateString(input: number, showOnes?: boo
 export declare function formatDateBySeconds(date: Date): string;
 export declare function formatDateByMinutes(date: Date): string;
 export declare function formatDate(date: Date): string;
-export declare function getDateBounds(datesArray: {
-    start: Date;
-    end: Date | null;
-}[], minimumTimeSpan?: number): {
+export declare function getDateBounds(data: TimelineData, minimumTimeSpan?: number, isRunning?: boolean): {
     min: Date;
     max: Date;
     span: number;
@@ -28,12 +28,15 @@ export declare const timeLengths: {
     week: number;
 };
 export declare const labelFormats: {
-    seconds: string;
-    minutes: string;
-    date: string;
+    readonly seconds: "seconds";
+    readonly minutes: "minutes";
+    readonly date: "date";
 };
-export declare const timeSpanSlots: {
+export type TimeSpan = {
     ceiling: number;
     span: number;
-    labelFormat: string;
-}[];
+    labelFormat: typeof labelFormats[keyof typeof labelFormats];
+};
+export declare const timeSpanSlots: TimeSpan[];
+export declare function getTimeSpanSlot(span: number): TimeSpan;
+export declare function getLabelFormatter(labelFormat: string, formatters: FormatDateFns): GuideDateFormatter;

package/dist/types/src/utilities/viewport.d.ts

@@ -0,0 +1,3 @@
+import { Viewport } from 'pixi-viewport';
+export type ViewportUpdatedCheck = () => boolean;
+export declare function viewportUpdatedFactory(viewport: Viewport): ViewportUpdatedCheck;

package/dist/types/src/utilities/zIndex.d.ts

@@ -0,0 +1,5 @@
+export declare const zIndex: {
+    readonly timelineGuides: 0;
+    readonly viewport: 10;
+    readonly playhead: 20;
+};

package/dist/types/src/workers/layouts/nearestNeighbor.d.ts

@@ -0,0 +1,10 @@
+import { NodesLayout, TimeScale } from '../../models';
+import { TimelineData } from '../../types/timeline';
+type FactoryArgs = {
+    data: TimelineData;
+    timeScale: TimeScale;
+    currentApxCharacterWidth: number;
+    minimumNodeEdgeGap: number;
+};
+export declare function generateNearestParentLayout({ data, timeScale, currentApxCharacterWidth, minimumNodeEdgeGap, }: FactoryArgs): Promise<NodesLayout>;
+export {};

package/dist/types/src/workers/layouts/waterfall.d.ts

@@ -0,0 +1,3 @@
+import { NodesLayout } from '../../models';
+import { TimelineData } from '../../types/timeline';
+export declare function generateWaterfallLayout(data: TimelineData): NodesLayout;