@prefecthq/graphs 2.0.5 → 2.1.0

package/dist/style.css

@@ -1 +1 @@
-.g-flow-run-timeline{position:relative;height:100%;width:100%;overflow:hidden}.g-flow-run-timeline canvas{position:absolute;top:0px;left:0px;height:100%;width:100%}
+.run-graph-settings{display:inline-block}.run-graph-settings__menu{padding:.5rem}.run-graph{position:relative}.run-graph--fullscreen{position:fixed;height:100vh!important;width:100vw!important;left:0;top:0}.run-graph__stage,.run-graph__stage>canvas{width:100%;height:100%}.run-graph__actions{position:absolute;bottom:0;right:0;padding:.5rem}

package/dist/types/demo/{sections/components/FlowRunTimelineDemo.vue.d.ts → components/AppComponentNavigationItems.vue.d.ts}

@@ -1,2 +1,7 @@
+import { RouteLocationRaw } from 'vue-router';
+export type ContextAccordionChildItem = {
+    to: RouteLocationRaw;
+    title?: string;
+};
 declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
 export default _default;

package/dist/types/demo/components/{HashLink.vue.d.ts → AppNavigationBar.vue.d.ts}

@@ -1,9 +1,11 @@
 declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
-    hash?: string | undefined;
+    layout?: "horizontal" | "vertical" | undefined;
 }>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
-    hash?: string | undefined;
+    layout?: "horizontal" | "vertical" | undefined;
 }>>>, {}, {}>, {
-    default?(_: {}): any;
+    prepend?(_: {
+        layout: "horizontal" | "vertical";
+    }): any;
 }>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

package/dist/types/demo/main.d.ts

@@ -1,2 +1,2 @@
 import '@prefecthq/prefect-design/dist/style.css';
-import './style.css';
+import '@/styles/style.css';

package/dist/types/src/components/RunGraph.vue.d.ts

@@ -0,0 +1,39 @@
+import { RunGraphProps } from '../models/RunGraph';
+import { NodeSelection } from '../models/selection';
+import { ViewportDateRange } from '../models/viewport';
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RunGraphProps>, {
+    fullscreen: null;
+    selected: null;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:viewport": (value: ViewportDateRange) => void;
+    "update:fullscreen": (value: boolean) => void;
+    "update:selected": (value: NodeSelection | null) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RunGraphProps>, {
+    fullscreen: null;
+    selected: null;
+}>>> & {
+    "onUpdate:viewport"?: ((value: ViewportDateRange) => any) | undefined;
+    "onUpdate:fullscreen"?: ((value: boolean) => any) | undefined;
+    "onUpdate:selected"?: ((value: NodeSelection | null) => any) | undefined;
+}, {
+    selected: NodeSelection | null;
+    fullscreen: boolean | null;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1 @@
+export { default as RunGraph } from './RunGraph.vue';

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

@@ -0,0 +1,16 @@
+export declare const DEFAULT_POLL_INTERVAL = 1000;
+export declare const DEFAULT_NODES_CONTAINER_NAME = "nodes-container";
+export declare const DEFAULT_NODE_CONTAINER_NAME = "node-container";
+export declare const DEFAULT_EDGE_CONTAINER_NAME = "edge-container";
+export declare const DEFAULT_TIME_COLUMN_SPAN_SECONDS = 1;
+export declare const DEFAULT_TIME_COLUMN_SIZE_PIXELS = 20;
+export declare const DEFAULT_LINEAR_COLUMN_SIZE_PIXELS = 200;
+export declare const DEFAULT_LABEL_CULLING_THRESHOLD = 0.2;
+export declare const DEFAULT_EDGE_CULLING_THRESHOLD = 0.1;
+export declare const DEFAULT_TEXTURE_RESOLUTION = 10;
+export declare const DEFAULT_EDGE_POINTS = 20;
+export declare const DEFAULT_EDGE_MINIMUM_BEZIER = 64;
+export declare const DEFAULT_HORIZONTAL_SCALE_MULTIPLIER = 0.25;
+export declare const DEFAULT_HORIZONTAL_SCALE = 1;
+export declare const DEFAULT_GUIDES_COUNT = 30;
+export declare const DEFAULT_GUIDES_MIN_GAP = 260;

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

@@ -0,0 +1,4 @@
+import gsap from 'gsap';
+export declare function animationFactory(): Promise<{
+    animate: (el: gsap.TweenTarget, vars: gsap.TweenVars, skipAnimation?: boolean) => gsap.core.Tween;
+}>;

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

@@ -0,0 +1,15 @@
+import { Sprite } from 'pixi.js';
+import { CornerStyle } from '../textures/corner';
+export declare enum ArrowDirection {
+    Up = 0,
+    Down = 180,
+    Left = 270,
+    Right = 90
+}
+export type ArrowStyle = CornerStyle & {
+    rotate?: number;
+};
+export declare function arrowFactory(): {
+    element: Sprite;
+    render: (style: ArrowStyle) => Promise<Sprite>;
+};

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

@@ -0,0 +1,13 @@
+import { ColorSource, Container } from 'pixi.js';
+export type BarStyle = {
+    width: number;
+    height: number;
+    background: ColorSource;
+    radius: number;
+    capLeft?: boolean;
+    capRight?: boolean;
+};
+export declare function barFactory(): Promise<{
+    element: Container<import("pixi.js").DisplayObject>;
+    render: (style: BarStyle) => Promise<Container>;
+}>;

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

@@ -0,0 +1,12 @@
+import { ColorSource, Container } from 'pixi.js';
+export type BorderStyle = {
+    width: number;
+    height: number;
+    stroke: number;
+    radius?: number;
+    color?: ColorSource;
+};
+export declare function borderFactory(): {
+    element: Container<import("pixi.js").DisplayObject>;
+    render: (style: BorderStyle) => Promise<Container>;
+};

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

@@ -0,0 +1,12 @@
+import { Sprite } from 'pixi.js';
+import { CapStyle } from '../textures/cap';
+type CapSprites = {
+    left: Sprite;
+    right: Sprite;
+};
+export declare function capFactory(): {
+    left: Sprite;
+    right: Sprite;
+    render: (style: CapStyle) => Promise<CapSprites>;
+};
+export {};

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

@@ -0,0 +1,7 @@
+import { RunGraphData } from '../models/RunGraph';
+type DataCallback = (data: RunGraphData) => void;
+export declare function dataFactory(runId: string, callback: DataCallback): Promise<{
+    start: () => Promise<void>;
+    stop: () => void;
+}>;
+export {};

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

@@ -0,0 +1,8 @@
+import { Container } from 'pixi.js';
+import { Pixels } from '../models/layout';
+export type EdgeFactory = Awaited<ReturnType<typeof edgeFactory>>;
+export declare function edgeFactory(): Promise<{
+    element: Container<import("pixi.js").DisplayObject>;
+    render: () => Promise<Container>;
+    setPosition: (source: Pixels, target: Pixels) => Promise<void>;
+}>;

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

@@ -0,0 +1,13 @@
+type Handler<T = any> = (...payload: T[]) => void;
+type Events = Record<string, unknown>;
+export declare function eventsFactory<T extends Events>(): {
+    on: <E extends keyof T>(event: E, handler: Handler<T[E]>) => () => void;
+    off: <E_1 extends keyof T>(event: E_1, handler: Handler<T[E_1]>) => void;
+    once: <E_2 extends keyof T>(event: E_2, handler: Handler<T[E_2]>) => void;
+    emit: {
+        <E_3 extends keyof T>(event: undefined extends T[E_3] ? E_3 : never): void;
+        <E_4 extends keyof T>(event: E_4, payload: T[E_4]): void;
+    };
+    clear: () => void;
+};
+export {};

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

@@ -0,0 +1,7 @@
+import { Container } from 'pixi.js';
+import { FormatDate } from '../models/guides';
+export type GuideFactory = Awaited<ReturnType<typeof guideFactory>>;
+export declare function guideFactory(): Promise<{
+    element: Container<import("pixi.js").DisplayObject>;
+    render: (date: Date, labelFormatter: FormatDate) => void;
+}>;

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

@@ -0,0 +1,5 @@
+import { Container } from 'pixi.js';
+export declare function guidesFactory(): Promise<{
+    element: Container<import("pixi.js").DisplayObject>;
+    render: () => void;
+}>;

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

@@ -0,0 +1,6 @@
+import { BitmapText } from 'pixi.js';
+import { RunGraphNode } from '../models/RunGraph';
+export declare function nodeLabelFactory(): Promise<{
+    element: BitmapText;
+    render: (node: RunGraphNode) => Promise<BitmapText>;
+}>;

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

@@ -0,0 +1,10 @@
+import { BoundsContainer } from '../models/boundsContainer';
+import { Pixels } from '../models/layout';
+import { RunGraphNode } from '../models/RunGraph';
+export type NodeContainerFactory = Awaited<ReturnType<typeof nodeContainerFactory>>;
+export declare function nodeContainerFactory(node: RunGraphNode): Promise<{
+    element: BoundsContainer;
+    render: (node: RunGraphNode) => Promise<BoundsContainer>;
+    bar: import("pixi.js").Container<import("pixi.js").DisplayObject>;
+    setPosition: ({ x, y }: Pixels) => void;
+}>;

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

@@ -0,0 +1,11 @@
+import { Container, ColorSource } from 'pixi.js';
+type NodeArrowBarStyles = {
+    inside: boolean;
+    background: ColorSource;
+    isOpen: boolean;
+};
+export declare function nodeArrowButtonFactory(): Promise<{
+    element: Container<import("pixi.js").DisplayObject>;
+    render: ({ inside, isOpen, background }: NodeArrowBarStyles) => Promise<Container>;
+}>;
+export {};

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

@@ -0,0 +1,6 @@
+import { Container } from 'pixi.js';
+import { RunGraphNode } from '../models/RunGraph';
+export declare function nodeBarFactory(): Promise<{
+    element: Container<import("pixi.js").DisplayObject>;
+    render: (node: RunGraphNode) => Promise<Container>;
+}>;

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

@@ -0,0 +1,9 @@
+import { BoundsContainer } from '../models/boundsContainer';
+import { RunGraphNode } from '../models/RunGraph';
+export type FlowRunContainer = Awaited<ReturnType<typeof flowRunContainerFactory>>;
+export declare function flowRunContainerFactory(node: RunGraphNode): Promise<{
+    kind: "flow-run";
+    element: BoundsContainer;
+    bar: import("pixi.js").Container<import("pixi.js").DisplayObject>;
+    render: (node: RunGraphNode) => Promise<BoundsContainer>;
+}>;

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

@@ -0,0 +1,9 @@
+import { BoundsContainer } from '../models/boundsContainer';
+import { RunGraphNode } from '../models/RunGraph';
+export type TaskRunContainer = Awaited<ReturnType<typeof taskRunContainerFactory>>;
+export declare function taskRunContainerFactory(): Promise<{
+    kind: "task-run";
+    element: BoundsContainer;
+    render: (node: RunGraphNode) => Promise<BoundsContainer>;
+    bar: import("pixi.js").Container<import("pixi.js").DisplayObject>;
+}>;

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

@@ -0,0 +1,11 @@
+import { Container } from 'pixi.js';
+import { RunGraphData } from '../models/RunGraph';
+export type NodesContainer = Awaited<ReturnType<typeof nodesContainerFactory>>;
+export declare function nodesContainerFactory(): Promise<{
+    element: Container<import("pixi.js").DisplayObject>;
+    getSize: () => {
+        width: number;
+        height: number;
+    };
+    render: (data: RunGraphData) => Promise<void>;
+}>;

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

@@ -0,0 +1,24 @@
+type SetOffsetParameters = {
+    axis: number;
+    nodeId: string;
+    offset: number;
+};
+type RemoveOffsetParameters = {
+    axis: number;
+    nodeId: string;
+};
+type MaybeGetter<T> = T | (() => T);
+export type Offsets = Awaited<ReturnType<typeof offsetsFactory>>;
+export type OffsetParameters = {
+    gap?: MaybeGetter<number>;
+    minimum?: MaybeGetter<number>;
+};
+export declare function offsetsFactory({ gap, minimum }?: OffsetParameters): {
+    getOffset: (axis: number) => number;
+    getTotalOffset: (axis: number) => number;
+    getTotalValue: (axis: number) => number;
+    setOffset: ({ axis, nodeId, offset }: SetOffsetParameters) => void;
+    removeOffset: ({ axis, nodeId }: RemoveOffsetParameters) => void;
+    clear: () => void;
+};
+export {};

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

@@ -0,0 +1,12 @@
+import { ScaleLinear, ScaleTime } from 'd3';
+import { HorizontalMode, VerticalMode } from '../models/layout';
+export type VerticalPositionSettings = {
+    mode: VerticalMode;
+};
+export type HorizontalPositionSettings = {
+    mode: HorizontalMode;
+    range: [number, number];
+    domain: [Date, Date] | [number, number];
+};
+export type HorizontalScale = ReturnType<typeof horizontalScaleFactory>;
+export declare function horizontalScaleFactory(settings: HorizontalPositionSettings): ScaleTime<number, number> | ScaleLinear<number, number>;

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

@@ -0,0 +1,2 @@
+import { Sprite } from 'pixi.js';
+export declare function rectangleFactory(): Promise<Sprite>;

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

@@ -0,0 +1,3 @@
+import { HorizontalPositionSettings, VerticalPositionSettings } from '../factories/position';
+export declare function horizontalSettingsFactory(startTime: Date): HorizontalPositionSettings;
+export declare function verticalSettingsFactory(): VerticalPositionSettings;

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

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

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

@@ -0,0 +1,70 @@
+import { ColorSource } from 'pixi.js';
+import { NodeSelection } from '../models/selection';
+import { StateType } from '../models/states';
+import { ViewportDateRange } from '../models/viewport';
+export type RunGraphProps = {
+    config: RunGraphConfig;
+    viewport?: ViewportDateRange;
+    fullscreen?: boolean | null;
+    selected?: NodeSelection | null;
+};
+export type RunGraphData = {
+    root_node_ids: string[];
+    start_time: Date;
+    end_time: Date | null;
+    nodes: RunGraphNodes;
+};
+export type RunGraphNodes = Map<string, RunGraphNode>;
+export type RunGraphNode = {
+    kind: RunGraphNodeKind;
+    id: string;
+    label: string;
+    state_name: string;
+    state_type: StateType;
+    start_time: Date;
+    end_time: Date | null;
+    parents: RunGraphEdge[];
+    children: RunGraphEdge[];
+};
+export type RunGraphEdge = {
+    id: string;
+};
+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 RunGraphNodeStyles = {
+    background?: ColorSource;
+};
+export type RunGraphStyles = {
+    rowGap?: number;
+    columnGap?: number;
+    nodesPadding?: number;
+    nodeHeight?: number;
+    nodePadding?: number;
+    nodeRadius?: number;
+    nodeBorderRadius?: number;
+    nodeToggleSize?: number;
+    nodeToggleBorderRadius?: number;
+    nodeToggleBorderColor?: ColorSource;
+    nodeSelectedBorderColor?: ColorSource;
+    edgeColor?: string;
+    guideLineWidth?: number;
+    guideLineColor?: string;
+    guideTextTopPadding?: number;
+    guideTextLeftPadding?: number;
+    guideTextSize?: number;
+    guideTextColor?: string;
+    node?: (node: RunGraphNode) => RunGraphNodeStyles;
+};
+export type RunGraphConfig = {
+    runId: string;
+    fetch: RunGraphFetch;
+    animationDuration?: number;
+    styles?: RunGraphStyles;
+    disableAnimationsThreshold?: number;
+    disableEdgesThreshold?: number;
+};
+export type RequiredGraphConfig = Omit<Required<RunGraphConfig>, 'styles'> & {
+    styles: Required<RunGraphStyles>;
+};

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

@@ -0,0 +1,15 @@
+import { Container } from 'pixi.js';
+/**
+ * This container extends the container from pixi but overrides
+ * the updateTransform and calculateBounds methods.
+ * The versions of these methods here are functional copies
+ * except these version also check children whose renderable
+ * or visible property is set to false. This means a BoundsContainer
+ * will have the same bounds even if some or all of its children are not
+ * rendered. This is important for any container where we need to know the actual
+ * size of the container even if its children have been culled.
+ */
+export declare class BoundsContainer extends Container {
+    updateTransform(): void;
+    calculateBounds(): void;
+}

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

@@ -0,0 +1,6 @@
+export type FormatDate = (date: Date) => string;
+export type FormatDateFns = {
+    timeBySeconds: FormatDate;
+    timeByMinutesWithDates: FormatDate;
+    date: FormatDate;
+};

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

@@ -1 +1,3 @@
-export * from './FlowRunTimeline';
+export * from './RunGraph';
+export * from './viewport';
+export * from './selection';

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

@@ -0,0 +1,35 @@
+export type Pixels = {
+    x: number;
+    y: number;
+};
+export type VerticalMode = 'waterfall' | 'nearest-parent';
+export type HorizontalMode = 'temporal' | 'dependency';
+export type NodeSize = {
+    height: number;
+    width: number;
+};
+export type LayoutSettings = {
+    horizontal: HorizontalMode;
+    vertical: VerticalMode;
+    horizontalScaleMultiplierDefault: number;
+    horizontalScaleMultiplier: number;
+    disableEdges: boolean;
+    disableAnimations: boolean;
+    disableGuides: boolean;
+    isTemporal: () => boolean;
+    isDependency: () => boolean;
+    isWaterfall: () => boolean;
+    isNearestParent: () => boolean;
+};
+export type NodeWidths = Map<string, number>;
+export type NodeLayoutResponse = {
+    x: number;
+    y: number;
+    column: number;
+    row: number;
+};
+export type NodesLayoutResponse = {
+    maxRow: number;
+    maxColumn: number;
+    positions: Map<string, NodeLayoutResponse>;
+};

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

@@ -0,0 +1,3 @@
+export declare class NonTemporalLayoutError extends Error {
+    constructor();
+}

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

@@ -0,0 +1,5 @@
+import { RunGraphNode } from '../models/RunGraph';
+export type NodeSelection = {
+    id: string;
+    kind: RunGraphNode['kind'];
+};

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

@@ -0,0 +1,2 @@
+export declare const stateType: readonly ["COMPLETED", "RUNNING", "SCHEDULED", "PENDING", "FAILED", "CANCELLED", "CANCELLING", "CRASHED", "PAUSED"];
+export type StateType = typeof stateType[number];

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

@@ -0,0 +1 @@
+export type ViewportDateRange = [start: Date, end: Date];

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

@@ -0,0 +1,5 @@
+import { Application } from 'pixi.js';
+export declare let application: Application | null;
+export declare function startApplication(): Promise<void>;
+export declare function stopApplication(): void;
+export declare function waitForApplication(): Promise<Application>;

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

@@ -0,0 +1,4 @@
+import { RequiredGraphConfig, RunGraphProps } from '../models/RunGraph';
+export declare function startConfig(props: RunGraphProps): Promise<void>;
+export declare function stopConfig(): void;
+export declare function waitForConfig(): Promise<RequiredGraphConfig>;

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

@@ -0,0 +1,6 @@
+import { Cull } from '@pixi-essentials/cull';
+export declare function startCulling(): Promise<void>;
+export declare function stopCulling(): void;
+export declare function cull(): Promise<void>;
+export declare function uncull(): void;
+export declare function waitForCull(): Promise<Cull>;

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

@@ -0,0 +1,4 @@
+import { VisibilityCull } from '../services/visibilityCull';
+export declare function startEdgeCulling(): Promise<void>;
+export declare function stopEdgeCulling(): void;
+export declare function waitForEdgeCull(): Promise<VisibilityCull>;

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

@@ -0,0 +1,48 @@
+import { Cull } from '@pixi-essentials/cull';
+import { Viewport } from 'pixi-viewport';
+import { Application, Container } from 'pixi.js';
+import { EffectScope } from 'vue';
+import { HorizontalScale } from '../factories/position';
+import { LayoutSettings } from '../models/layout';
+import { RequiredGraphConfig, RunGraphData } from '../models/RunGraph';
+import { NodeSelection } from '../models/selection';
+import { ViewportDateRange } from '../models/viewport';
+import { Fonts } from '../objects/fonts';
+import { VisibilityCull } from '../services/visibilityCull';
+type Events = {
+    scaleCreated: HorizontalScale;
+    scaleUpdated: HorizontalScale;
+    applicationCreated: Application;
+    applicationResized: Application;
+    stageCreated: HTMLDivElement;
+    stageUpdated: HTMLDivElement;
+    viewportCreated: Viewport;
+    viewportDateRangeUpdated: ViewportDateRange;
+    configCreated: RequiredGraphConfig;
+    configUpdated: RequiredGraphConfig;
+    scopeCreated: EffectScope;
+    fontsLoaded: Fonts;
+    containerCreated: Container;
+    layoutSettingsUpdated: LayoutSettings;
+    layoutSettingsCreated: LayoutSettings;
+    cullCreated: Cull;
+    labelCullCreated: VisibilityCull;
+    edgeCullCreated: VisibilityCull;
+    runDataCreated: RunGraphData;
+    runDataUpdated: RunGraphData;
+    nodeSelected: NodeSelection | null;
+    layoutUpdated: void;
+};
+export type EventKey = keyof Events;
+export declare const emitter: {
+    on: <E extends keyof Events>(event: E, handler: (...payload: Events[E][]) => void) => () => void;
+    off: <E_1 extends keyof Events>(event: E_1, handler: (...payload: Events[E_1][]) => void) => void;
+    once: <E_2 extends keyof Events>(event: E_2, handler: (...payload: Events[E_2][]) => void) => void;
+    emit: {
+        <E_3 extends keyof Events>(event: undefined extends Events[E_3] ? E_3 : never): void;
+        <E_4 extends keyof Events>(event: E_4, payload: Events[E_4]): void;
+    };
+    clear: () => void;
+};
+export declare function waitForEvent<T extends EventKey>(event: T): Promise<Events[T]>;
+export {};

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

@@ -0,0 +1,9 @@
+import { BitmapText } from 'pixi.js';
+declare const fonts: {
+    readonly inter: (text: string) => BitmapText;
+};
+export type Fonts = typeof fonts;
+export declare function startFonts(): Promise<void>;
+export declare function stopFonts(): void;
+export declare function waitForFonts(): Promise<Fonts>;
+export {};

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

@@ -0,0 +1,2 @@
+export declare function startGuides(): Promise<void>;
+export declare function stopGuides(): void;

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

@@ -0,0 +1,10 @@
+import { RunGraphProps } from '../models/RunGraph';
+export * from './application';
+export * from './stage';
+export * from './viewport';
+type StartParameters = {
+    stage: HTMLDivElement;
+    props: RunGraphProps;
+};
+export declare function start({ stage, props }: StartParameters): void;
+export declare function stop(): void;

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

@@ -0,0 +1,4 @@
+import { VisibilityCull } from '../services/visibilityCull';
+export declare function startLabelCulling(): Promise<void>;
+export declare function stopLabelCulling(): void;
+export declare function waitForLabelCull(): Promise<VisibilityCull>;

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

@@ -0,0 +1,4 @@
+import { RunGraphData } from '../models/RunGraph';
+export declare function startNodes(): Promise<void>;
+export declare function stopNodes(): void;
+export declare function waitForRunData(): Promise<RunGraphData>;

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

@@ -0,0 +1,4 @@
+import { HorizontalScale } from '../factories/position';
+export declare function startScale(): Promise<void>;
+export declare function stopScale(): void;
+export declare function waitForScale(): Promise<HorizontalScale>;

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

@@ -0,0 +1,4 @@
+import { EffectScope } from 'vue';
+export declare function startScope(): void;
+export declare function stopScope(): void;
+export declare function waitForScope(): Promise<EffectScope>;

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

@@ -0,0 +1,5 @@
+import { NodeSelection } from '../models/selection';
+export declare function startSelection(): Promise<void>;
+export declare function stopSelection(): void;
+export declare function selectNode(node: NodeSelection | null): void;
+export declare function isSelected(selection: NodeSelection | null): boolean;