@prefecthq/graphs 2.2.7 → 2.2.9

package/dist/types/src/factories/artifact.d.ts

@@ -2,8 +2,9 @@ import { RunGraphArtifact } from '../models/artifact';
 export type ArtifactFactory = Awaited<ReturnType<typeof artifactFactory>>;
 type ArtifactFactoryOptions = {
     cullAtZoomThreshold?: boolean;
+    enableLocalClickHandling?: boolean;
 };
-export declare function artifactFactory(artifact: RunGraphArtifact, { cullAtZoomThreshold }?: ArtifactFactoryOptions): Promise<{
+export declare function artifactFactory(artifact: RunGraphArtifact, { cullAtZoomThreshold, enableLocalClickHandling, }?: ArtifactFactoryOptions): Promise<{
     element: import("pixi.js").Container<import("pixi.js").DisplayObject>;
     render: () => Promise<void>;
     getSelected: () => boolean;

package/dist/types/src/factories/border.d.ts

@@ -3,7 +3,7 @@ export type BorderStyle = {
     width: number;
     height: number;
     stroke: number;
-    radius?: number;
+    radius?: number | [number, number, number, number];
     color?: ColorSource;
 };
 export declare function borderFactory(): {

package/dist/types/src/factories/eventData.d.ts

@@ -1,6 +1,7 @@
-import { RunGraphEvent } from '../models';
+import { MaybeRefOrGetter } from 'vue';
+import { RunGraphEvent, RunGraphFetchEventsOptions } from '../models';
 type EventDataCallback = (data: RunGraphEvent[]) => void;
-export declare function eventDataFactory(runId: string, callback: EventDataCallback): Promise<{
+export declare function eventDataFactory(runId: string, callback: EventDataCallback, options?: MaybeRefOrGetter<RunGraphFetchEventsOptions>): Promise<{
     start: () => Promise<void>;
     stop: () => void;
 }>;

package/dist/types/src/factories/flowRunState.d.ts

@@ -1,11 +1,11 @@
 import { Container } from 'pixi.js';
 import { RunGraphStateEvent } from '../models/states';
 export type FlowRunStateFactory = Awaited<ReturnType<typeof flowRunStateFactory>>;
-type FlowRunStateFactoryOptions = {
+type FlowRunStateFactoryRenderProps = {
     end: Date;
 };
-export declare function flowRunStateFactory(state: RunGraphStateEvent, options?: FlowRunStateFactoryOptions): Promise<{
+export declare function flowRunStateFactory(state: RunGraphStateEvent): Promise<{
     element: Container<import("pixi.js").DisplayObject>;
-    render: (newOptions?: FlowRunStateFactoryOptions) => void;
+    render: (newOptions?: FlowRunStateFactoryRenderProps) => void;
 }>;
 export {};

package/dist/types/src/factories/nodeFlowRunArtifact.d.ts

@@ -0,0 +1,20 @@
+import { ArtifactFactory } from '../factories/artifact';
+import { ArtifactClusterFactory } from '../factories/artifactCluster';
+import { RunGraphArtifact } from '../models';
+export type NodeFlowRunArtifactFactory = Awaited<ReturnType<typeof nodeFlowRunArtifactFactory>>;
+type NodeFlowRunArtifactFactorySharedOptions = {
+    parentStartDate?: Date;
+};
+type NodeFlowRunArtifactFactoryOptions = NodeFlowRunArtifactFactorySharedOptions & ({
+    type: 'artifact';
+    artifact: RunGraphArtifact;
+} | {
+    type: 'cluster';
+});
+type FactoryType<T> = T extends {
+    type: 'artifact';
+} ? ArtifactFactory : T extends {
+    type: 'cluster';
+} ? ArtifactClusterFactory : never;
+export declare function nodeFlowRunArtifactFactory<T extends NodeFlowRunArtifactFactoryOptions>(options: T): Promise<FactoryType<T>>;
+export {};

package/dist/types/src/factories/nodeFlowRunEvent.d.ts

@@ -0,0 +1,20 @@
+import { EventFactory } from '../factories/event';
+import { EventClusterFactory } from '../factories/eventCluster';
+import { RunGraphEvent } from '../models';
+export type NodeFlowRunEventFactory = Awaited<ReturnType<typeof nodeFlowRunEventFactory>>;
+type NodeEventFactorySharedOptions = {
+    parentStartDate?: Date;
+};
+type NodeEventFactoryOptions = NodeEventFactorySharedOptions & ({
+    type: 'event';
+    event: RunGraphEvent;
+} | {
+    type: 'cluster';
+});
+type EventFactoryType<T> = T extends {
+    type: 'event';
+} ? EventFactory : T extends {
+    type: 'cluster';
+} ? EventClusterFactory : never;
+export declare function nodeFlowRunEventFactory<T extends NodeEventFactoryOptions>(options: T): Promise<EventFactoryType<T>>;
+export {};

package/dist/types/src/factories/nodeFlowRunState.d.ts

@@ -0,0 +1,16 @@
+import { Container } from 'pixi.js';
+import { FlowRunStateFactory } from '../factories/flowRunState';
+import { RunGraphStateEvent } from '../models/states';
+export type NodeFlowRunStateFactory = Awaited<ReturnType<typeof nodeFlowRunStateFactory>>;
+export declare function isNodeFlowRunStateFactory(factory: NodeFlowRunStateFactory | FlowRunStateFactory): factory is NodeFlowRunStateFactory;
+export type NodeFlowRunStateFactoryRenderProps = {
+    end?: Date;
+    parentStartDate?: Date;
+    width?: number;
+    height?: number;
+};
+export declare function nodeFlowRunStateFactory(state: RunGraphStateEvent): Promise<{
+    element: Container<import("pixi.js").DisplayObject>;
+    render: (props?: NodeFlowRunStateFactoryRenderProps) => void;
+    isNodesFlowRunStateFactory: boolean;
+}>;

package/dist/types/src/factories/runArtifacts.d.ts

@@ -0,0 +1,12 @@
+import { Container } from 'pixi.js';
+import { RunGraphArtifact } from '../models';
+type RunEventsFactoryProps = {
+    isRoot?: boolean;
+    parentStartDate?: Date;
+};
+export declare function runArtifactsFactory({ isRoot, parentStartDate }?: RunEventsFactoryProps): Promise<{
+    element: Container<import("pixi.js").DisplayObject>;
+    render: (newData?: RunGraphArtifact[]) => Promise<void>;
+    update: () => void;
+}>;
+export {};

package/dist/types/src/factories/runEvents.d.ts

@@ -0,0 +1,12 @@
+import { Container } from 'pixi.js';
+import { RunGraphEvent } from '../models';
+type RunEventsFactoryProps = {
+    isRoot?: boolean;
+    parentStartDate?: Date;
+};
+export declare function runEventsFactory({ isRoot, parentStartDate }?: RunEventsFactoryProps): Promise<{
+    element: Container<import("pixi.js").DisplayObject>;
+    render: (newData?: RunGraphEvent[]) => Promise<void>;
+    update: () => void;
+}>;
+export {};

package/dist/types/src/factories/runStates.d.ts

@@ -0,0 +1,11 @@
+import { Container } from 'pixi.js';
+import { NodeFlowRunStateFactoryRenderProps } from '../factories/nodeFlowRunState';
+import { RunGraphStateEvent } from '../models/states';
+type FlowRunStatesFactoryProps = {
+    isRoot?: boolean;
+};
+export declare function runStatesFactory({ isRoot }?: FlowRunStatesFactoryProps): {
+    element: Container<import("pixi.js").DisplayObject>;
+    render: (newStateData?: RunGraphStateEvent[], nodesStateOptions?: NodeFlowRunStateFactoryRenderProps) => Promise<void>;
+};
+export {};

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

@@ -37,7 +37,11 @@ export declare const runGraphNodeKinds: readonly ["flow-run", "task-run"];
 export type RunGraphNodeKind = typeof runGraphNodeKinds[number];
 export declare function isRunGraphNodeType(value: unknown): value is RunGraphNodeKind;
 export type RunGraphFetch = (runId: string) => RunGraphData | Promise<RunGraphData>;
-export type RunGraphFetchEvents = (runId: string) => RunGraphEvent[] | Promise<RunGraphEvent[]>;
+export type RunGraphFetchEventsOptions = {
+    since?: Date;
+    until?: Date;
+};
+export type RunGraphFetchEvents = (runId: string, options?: RunGraphFetchEventsOptions) => RunGraphEvent[] | Promise<RunGraphEvent[]>;
 export type RunGraphNodeStyles = {
     background?: ColorSource;
 };

package/dist/types/src/objects/flowRunEvents.d.ts

@@ -1,2 +1,4 @@
+import { RunGraphEvent } from '../models';
 export declare function startFlowRunEvents(): Promise<void>;
 export declare function stopFlowRunEvents(): void;
+export declare function waitForRunEvents(): Promise<RunGraphEvent[] | null>;

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

@@ -13,6 +13,7 @@ type ClusterFactory = {
         date: Date;
     }) => void;
 } & Record<string, unknown>;
+export declare function itemIsClusterFactory(item: ItemFactory | ClusterFactory): item is ClusterFactory;
 type ClusterHorizontalCollisionsProps = {
     items: Map<string, ItemFactory | ClusterFactory>;
     createCluster: () => Promise<ClusterFactory>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prefecthq/graphs",
   "private": false,
-  "version": "2.2.7",
+  "version": "2.2.9",
   "description": "Large scale graphs designed for Prefect",
   "scripts": {
     "serve": "vite --host --mode=demo",

package/dist/types/src/factories/flowRunArtifacts.d.ts

@@ -1,4 +0,0 @@
-import { RunGraphArtifact } from '../models';
-export declare function flowRunArtifactsFactory(): Promise<{
-    render: (newData?: RunGraphArtifact[]) => Promise<void>;
-}>;

package/dist/types/src/factories/flowRunEvents.d.ts

@@ -1,4 +0,0 @@
-import { RunGraphEvent } from '../models';
-export declare function flowRunEventsFactory(): Promise<{
-    render: (newData?: RunGraphEvent[]) => Promise<void>;
-}>;

package/dist/types/src/factories/flowRunStates.d.ts

@@ -1,6 +0,0 @@
-import { Container } from 'pixi.js';
-import { RunGraphStateEvent } from '../models/states';
-export declare function flowRunStatesFactory(): {
-    element: Container<import("pixi.js").DisplayObject>;
-    render: (newStateData?: RunGraphStateEvent[]) => Promise<void>;
-};