@prefecthq/graphs 0.1.10 → 0.1.12

package/dist/style.css

@@ -1 +1 @@
-.flow-run-timeline{position:relative;height:100%;width:100%;overflow:hidden;border-radius:.5rem;--tw-bg-opacity: 1;background-color:rgb(241 245 249 / var(--tw-bg-opacity))}.flow-run-timeline canvas{position:absolute;top:0px;left:0px;height:100%;width:100%}
+.flow-run-timeline{position:relative;height:100%;width:100%;overflow:hidden}.flow-run-timeline canvas{position:absolute;top:0px;left:0px;height:100%;width:100%}

package/dist/types/demo/utilities/timescaleData.d.ts

@@ -6,13 +6,14 @@ export type DataOptions = {
     shape?: Shape;
     size?: number;
     fanMultiplier?: number;
+    zeroTimeGap?: boolean;
 };
 type TimescaleItem = {
     id: string;
     label: string;
     start: Date;
     end: Date | null;
-    upstreamDependencies: TimescaleItem[];
+    upstreamDependencies: string[];
     state: TimelineNodeState;
 };
 declare const generateTimescaleData: (options?: DataOptions) => TimescaleItem[];

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

@@ -1,4 +1,4 @@
-import { TimelineNodeData } from './models';
+import { TimelineNodeData, TimelineThemeOptions, FormatDateFns, TimelineNodesLayoutOptions } from './models';
 declare const _default: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
@@ -6,10 +6,13 @@ declare const _default: {
         $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
             graphData: TimelineNodeData[];
             isRunning?: boolean | undefined;
-            formatTimeBySeconds: (date: Date) => string;
-            formatTimeByMinutes: (date: Date) => string;
-            formatDate: (date: Date) => string;
-        }>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+            theme?: TimelineThemeOptions | undefined;
+            formatDateFns?: Partial<FormatDateFns> | undefined;
+            selectedNodeId?: string | null | undefined;
+            layout?: TimelineNodesLayoutOptions | undefined;
+        }>>> & {
+            onClick?: ((value: string | null) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
         $attrs: {
             [x: string]: unknown;
         };
@@ -21,15 +24,20 @@ declare const _default: {
         }>;
         $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: string, ...args: any[]) => void;
+        $emit: (event: "click", value: string | null) => void;
         $el: any;
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
             graphData: TimelineNodeData[];
             isRunning?: boolean | undefined;
-            formatTimeBySeconds: (date: Date) => string;
-            formatTimeByMinutes: (date: Date) => string;
-            formatDate: (date: Date) => string;
-        }>>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+            theme?: TimelineThemeOptions | undefined;
+            formatDateFns?: Partial<FormatDateFns> | undefined;
+            selectedNodeId?: string | null | undefined;
+            layout?: TimelineNodesLayoutOptions | undefined;
+        }>>> & {
+            onClick?: ((value: string | null) => any) | undefined;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            click: (value: string | null) => void;
+        }, string, {}, {}, string> & {
             beforeCreate?: ((() => void) | (() => void)[]) | undefined;
             created?: ((() => void) | (() => void)[]) | undefined;
             beforeMount?: ((() => void) | (() => void)[]) | undefined;
@@ -52,20 +60,28 @@ declare const _default: {
     } & Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
         graphData: TimelineNodeData[];
         isRunning?: boolean | undefined;
-        formatTimeBySeconds: (date: Date) => string;
-        formatTimeByMinutes: (date: Date) => string;
-        formatDate: (date: Date) => string;
-    }>>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+        theme?: TimelineThemeOptions | undefined;
+        formatDateFns?: Partial<FormatDateFns> | undefined;
+        selectedNodeId?: string | null | undefined;
+        layout?: TimelineNodesLayoutOptions | undefined;
+    }>>> & {
+        onClick?: ((value: string | null) => any) | undefined;
+    } & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: undefined;
     __isTeleport?: undefined;
     __isSuspense?: undefined;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
     graphData: TimelineNodeData[];
     isRunning?: boolean | undefined;
-    formatTimeBySeconds: (date: Date) => string;
-    formatTimeByMinutes: (date: Date) => string;
-    formatDate: (date: Date) => string;
-}>>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+    theme?: TimelineThemeOptions | undefined;
+    formatDateFns?: Partial<FormatDateFns> | undefined;
+    selectedNodeId?: string | null | undefined;
+    layout?: TimelineNodesLayoutOptions | undefined;
+}>>> & {
+    onClick?: ((value: string | null) => any) | undefined;
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (value: string | null) => void;
+}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
 type __VLS_TypePropsToRuntimeProps<T> = {

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

@@ -1,15 +1,133 @@
-import { IBitmapTextStyle } from 'pixi.js';
-export type TimelineNodeState = 'completed' | 'running' | 'scheduled' | 'pending' | 'failed' | 'cancelled' | 'crashed' | 'paused';
+import { IBitmapTextStyle, TextStyle } from 'pixi.js';
 export type TimelineNodeData = {
     id: string;
     label: string;
     start: Date;
     end: Date | null;
-    upstreamDependencies?: TimelineNodeData[];
-    state: TimelineNodeState | string;
+    upstreamDependencies?: string[];
+    state: string;
+};
+export type InitTimelineScaleProps = {
+    minimumStartTime: number;
+    overallGraphWidth: number;
+    initialOverallTimeSpan: number;
+};
+export type TimelineNodesLayoutOptions = 'waterfall' | 'nearestParent';
+export type NodeShoveDirection = 1 | -1;
+export type NodeLayoutWorkerProps = {
+    data: {
+        layoutSetting?: TimelineNodesLayoutOptions;
+        graphData: string;
+        defaultTextStyles?: TextStyle;
+        spacingMinimumNodeEdgeGap?: number;
+        timeScaleProps?: InitTimelineScaleProps;
+    };
+};
+export type NodeLayoutItem = {
+    position: number;
+    nextDependencyShove?: NodeShoveDirection;
+    startX: number;
+    endX: number;
+};
+export type NodesLayout = Record<string, NodeLayoutItem>;
+export type NodeLayoutWorkerResponse = {
+    data: NodesLayout;
+};
+export type DateToX = (date: Date) => number;
+export type XToDate = (xPosition: number) => number;
+export type TimelineScale = {
+    dateToX: DateToX;
+    xToDate: XToDate;
 };
 export type TextStyles = {
     nodeTextDefault: Partial<IBitmapTextStyle>;
     nodeTextInverse: Partial<IBitmapTextStyle>;
+    nodeTextStyles: TextStyle;
     timeMarkerLabel: Partial<IBitmapTextStyle>;
 };
+type FormatDate = (date: Date) => string;
+export type FormatDateFns = {
+    timeBySeconds: FormatDate;
+    timeByMinutes: FormatDate;
+    date: FormatDate;
+};
+export declare const formatDateFnsDefault: FormatDateFns;
+type NodeThemeOptions = {
+    fill: string;
+    inverseTextOnFill: boolean;
+};
+export type NodeThemeFn = (node: TimelineNodeData) => NodeThemeOptions;
+export declare const nodeThemeFnDefault: NodeThemeFn;
+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})`;
+export type HEX = `#${string}`;
+export type Color = RGB | RGBA | HSL | HEX;
+export type ThemeStyleOverrides = {
+    colorTextDefault?: Color;
+    colorTextInverse?: Color;
+    colorTextSubdued?: Color;
+    colorNodeSelection?: Color;
+    colorEdge?: Color;
+    colorGuideLine?: Color;
+    colorPlayheadBg?: Color;
+    textFontFamilyDefault?: string;
+    textSizeDefault?: Sizing;
+    textSizeSmall?: Sizing;
+    textLineHeightDefault?: Sizing;
+    textLineHeightSmall?: Sizing;
+    spacingViewportPaddingDefault?: Sizing;
+    spacingNodeXPadding?: Sizing;
+    spacingNodeYPadding?: Sizing;
+    spacingNodeMargin?: Sizing;
+    spacingNodeLabelMargin?: Sizing;
+    spacingMinimumNodeEdgeGap?: Sizing;
+    spacingNodeEdgeLength?: Sizing;
+    spacingNodeSelectionMargin?: Sizing;
+    spacingNodeSelectionWidth?: Sizing;
+    spacingEdgeWidth?: Sizing;
+    spacingGuideLabelPadding?: Sizing;
+    spacingPlayheadWidth?: Sizing;
+    spacingPlayheadGlowPadding?: Sizing;
+    borderRadiusNode?: Sizing;
+    alphaNodeDimmed?: number;
+};
+export type ParsedThemeStyles = {
+    colorTextDefault: number;
+    colorTextInverse: number;
+    colorTextSubdued: number;
+    colorNodeSelection: number;
+    colorEdge: number;
+    colorGuideLine: number;
+    colorPlayheadBg: number;
+    textFontFamilyDefault: string;
+    textSizeDefault: number;
+    textSizeSmall: number;
+    textLineHeightDefault: number;
+    textLineHeightSmall: number;
+    spacingViewportPaddingDefault: number;
+    spacingNodeXPadding: number;
+    spacingNodeYPadding: number;
+    spacingNodeMargin: number;
+    spacingNodeLabelMargin: number;
+    spacingMinimumNodeEdgeGap: number;
+    spacingNodeEdgeLength: number;
+    spacingNodeSelectionMargin: number;
+    spacingNodeSelectionWidth: number;
+    spacingEdgeWidth: number;
+    spacingGuideLabelPadding: number;
+    spacingPlayheadWidth: number;
+    spacingPlayheadGlowPadding: number;
+    borderRadiusNode: number;
+    alphaNodeDimmed: number;
+};
+export type TimelineThemeOptions = {
+    node?: NodeThemeFn;
+    defaults?: ThemeStyleOverrides;
+};
+export type ParsedThemeOptions = {
+    node: NodeThemeFn;
+    defaults: ParsedThemeStyles;
+};
+export {};

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

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

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

@@ -0,0 +1,12 @@
+import type { Viewport } from 'pixi-viewport';
+import { Application, Container } from 'pixi.js';
+export declare class DeselectLayer extends Container {
+    private readonly appRef;
+    private readonly viewportRef;
+    private readonly layer;
+    constructor(appRef: Application, viewportRef: Viewport);
+    private drawLayer;
+    private getDimensions;
+    private initUpdater;
+    private update;
+}

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

@@ -1,6 +1,9 @@
 export * from './bitmapFonts';
+export * from './deselectLayer';
 export * from './initPixiApp';
 export * from './initViewport';
+export * from './timelineEdge';
 export * from './timelineGuides';
-export * from './timelineNode';
+export * from './timelineNodes';
 export * from './timelinePlayhead';
+export * from './timelineScale';

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

@@ -0,0 +1,32 @@
+import { Container } from 'pixi.js';
+import { ComputedRef } from 'vue';
+import { TimelineNode } from './timelineNode';
+import { ParsedThemeStyles } from '../models';
+type TimelineEdgeProps = {
+    styles: ComputedRef<ParsedThemeStyles>;
+    sourceNode: TimelineNode;
+    targetNode: TimelineNode;
+};
+export declare class TimelineEdge extends Container {
+    private readonly styles;
+    private readonly sourceNode;
+    private readonly targetNode;
+    private sourceX;
+    private sourceY;
+    private targetX;
+    private targetY;
+    private directionFromSource;
+    private readonly edge;
+    private readonly arrow;
+    private readonly unwatch;
+    constructor({ styles, sourceNode, targetNode, }: TimelineEdgeProps);
+    private assignStartAndEndPositions;
+    private drawEdge;
+    private readonly getSourcePosition;
+    private readonly getSourceBezier;
+    private readonly getTargetBezier;
+    private drawArrow;
+    update(): void;
+    destroy(): void;
+}
+export {};

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

@@ -1,11 +1,20 @@
 import { Container } from 'pixi.js';
+import { ComputedRef } from 'vue';
+import { ParsedThemeStyles } from '../models';
+type TimelineGuideProps = {
+    labelText: string | null;
+    styles: ComputedRef<ParsedThemeStyles>;
+    appHeight: number;
+};
 export declare class TimelineGuide extends Container {
     private readonly labelText;
-    private guideHeight;
+    private readonly styles;
+    private appHeight;
     private readonly guideLine;
     private label;
-    constructor(labelText: string | null, guideHeight: number);
+    constructor({ labelText, styles, appHeight, }: TimelineGuideProps);
     private drawGuideLine;
     private drawLabel;
-    updateHeight(guideHeight: number): void;
+    updateHeight(appHeight: number): void;
 }
+export {};

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

@@ -1,35 +1,31 @@
 import type { Viewport } from 'pixi-viewport';
 import { Container } from 'pixi.js';
 import type { Application } from 'pixi.js';
-import type { Ref } from 'vue';
+import { ComputedRef, Ref } from 'vue';
+import { FormatDateFns, ParsedThemeStyles } from '../models';
 type TimelineGuidesProps = {
     viewportRef: Viewport;
     appRef: Application;
-    xScale: (x: Date) => number;
-    dateScale: (x: number) => number;
     minimumStartDate: Date;
     maximumEndDate: Ref<Date | undefined>;
     isRunning: boolean;
-    formatTimeBySeconds: (date: Date) => string;
-    formatTimeByMinutes: (date: Date) => string;
-    formatDate: (date: Date) => string;
+    styles: ComputedRef<ParsedThemeStyles>;
+    formatDateFns: ComputedRef<FormatDateFns>;
 };
 export declare class TimelineGuides extends Container {
     private readonly viewportRef;
     private readonly appRef;
-    private readonly xScale;
-    private readonly dateScale;
     private readonly minimumStartDate;
     private readonly maximumEndDate;
     private readonly isRunning;
-    private readonly formatTimeBySeconds;
-    private readonly formatTimeByMinutes;
-    private readonly formatDate;
+    private readonly styles;
+    private readonly formatDateFns;
+    private readonly unwatch;
     private idealGuideCount;
     private currentTimeGap;
     private labelFormatter;
     private readonly guides;
-    constructor({ viewportRef, appRef, xScale, dateScale, minimumStartDate, maximumEndDate, isRunning, formatTimeBySeconds, formatTimeByMinutes, formatDate, }: TimelineGuidesProps);
+    constructor({ viewportRef, appRef, minimumStartDate, maximumEndDate, isRunning, styles, formatDateFns, }: TimelineGuidesProps);
     updateGuides(): void;
     private updateIdealGuideCount;
     private updateCurrentTimeGap;

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

@@ -1,20 +1,38 @@
 import { Container } from 'pixi.js';
-import { TimelineNodeData } from '../models';
+import { ComputedRef } from 'vue';
+import { ParsedThemeStyles, TimelineNodeData, NodeThemeFn } from '../models';
+type TimelineNodeProps = {
+    nodeData: TimelineNodeData;
+    styles: ComputedRef<ParsedThemeStyles>;
+    styleNode: ComputedRef<NodeThemeFn>;
+    layoutPosition: number;
+};
+export declare const timelineNodeBoxName = "box";
 export declare class TimelineNode extends Container {
     nodeData: TimelineNodeData;
-    private readonly xScale;
+    private readonly styles;
+    private readonly styleNode;
+    private readonly unwatch;
     private label;
     private readonly box;
     private apxLabelWidth;
     private nodeWidth;
-    private readonly yPositionIndex;
+    private readonly layoutPositionOffset;
+    layoutPosition: number;
     private isLabelInBox;
-    constructor(nodeData: TimelineNodeData, xScale: (date: Date) => number, yPositionIndex: number);
+    private readonly selectedRing;
+    constructor({ nodeData, styles, styleNode, layoutPosition, }: TimelineNodeProps);
     private getNodeWidth;
-    private get boxColor();
+    private getLayoutPositionOffset;
     private drawBox;
     private drawLabel;
-    private updatePosition;
+    private drawSelectedRing;
+    private animateIn;
+    updatePosition(skipAnimation?: boolean): Promise<void>;
     private updateLabelPosition;
-    update(newNodeData?: TimelineNodeData): void;
+    update(newNodeData?: TimelineNodeData): Promise<void>;
+    select(): void;
+    deselect(): void;
+    destroy(): void;
 }
+export {};

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

@@ -0,0 +1,45 @@
+import type { Viewport } from 'pixi-viewport';
+import { Application, Container } from 'pixi.js';
+import { ComputedRef } from 'vue';
+import { TimelineNode } from './timelineNode';
+import { NodeThemeFn, ParsedThemeStyles, TimelineNodeData, TimelineNodesLayoutOptions, InitTimelineScaleProps } from '../models';
+type TimelineNodesProps = {
+    appRef: Application;
+    viewportRef: Viewport;
+    graphData: TimelineNodeData[];
+    styles: ComputedRef<ParsedThemeStyles>;
+    styleNode: ComputedRef<NodeThemeFn>;
+    timeScaleProps: InitTimelineScaleProps;
+    layoutSetting?: TimelineNodesLayoutOptions;
+};
+export declare class TimelineNodes extends Container {
+    private readonly appRef;
+    private readonly viewportRef;
+    private graphData;
+    private readonly styles;
+    private readonly styleNode;
+    private readonly nodeContainer;
+    readonly nodeRecords: Map<string, TimelineNode>;
+    selectedNodeId: string | null | undefined;
+    private readonly layoutSetting;
+    private readonly layoutWorker;
+    private layout;
+    private readonly edgeContainer;
+    private readonly edgeRecords;
+    constructor({ appRef, viewportRef, graphData, styles, styleNode, layoutSetting, timeScaleProps: { minimumStartTime, overallGraphWidth, initialOverallTimeSpan, }, }: TimelineNodesProps);
+    private initLayoutWorker;
+    private initDeselectLayer;
+    private renderLayout;
+    private updateNodeRecordAndEdgesLayout;
+    private createNode;
+    private fitNodesInViewport;
+    private addEdges;
+    update(newData?: TimelineNodeData[]): void;
+    updateSelection(selectedNodeId?: string | null): void;
+    private highlightSelectedNodePath;
+    private unHighlightAll;
+    private getAllUpstreamEdges;
+    private getAllDownstreamEdges;
+    destroy(): void;
+}
+export {};

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

@@ -1,18 +1,22 @@
 import type { Viewport } from 'pixi-viewport';
 import { Container } from 'pixi.js';
 import type { Application } from 'pixi.js';
+import { ComputedRef } from 'vue';
+import { ParsedThemeStyles } from '../models';
 type TimelinePlayheadProps = {
     viewportRef: Viewport;
     appRef: Application;
-    xScale: (date: Date) => number;
+    styles: ComputedRef<ParsedThemeStyles>;
 };
 export declare class TimelinePlayhead extends Container {
     private readonly viewportRef;
     private readonly appRef;
-    private readonly xScale;
+    private readonly styles;
+    private readonly unwatch;
     private readonly playhead;
-    constructor({ viewportRef, appRef, xScale, }: TimelinePlayheadProps);
+    constructor({ viewportRef, appRef, styles, }: TimelinePlayheadProps);
     private drawPlayhead;
     updatePosition(): void;
+    destroy(): void;
 }
 export {};

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

@@ -0,0 +1,7 @@
+import { DateToX, XToDate, TimelineScale, InitTimelineScaleProps } from '../models';
+export declare let timelineScale: {
+    dateToX: DateToX;
+    xToDate: XToDate;
+};
+export declare const createTimelineScale: ({ minimumStartTime, overallGraphWidth, initialOverallTimeSpan, }: InitTimelineScaleProps) => TimelineScale;
+export declare const initTimelineScale: ({ minimumStartTime, overallGraphWidth, initialOverallTimeSpan, }: InitTimelineScaleProps) => TimelineScale;

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

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

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

@@ -0,0 +1 @@
+export declare function mapSome<K, V>(map: Map<K, V>, callback: (value: V, key: K) => boolean): boolean;

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

@@ -1,4 +1,4 @@
-export declare const abs: (x: number) => number, atan2: (y: number, x: number) => number, cos: (x: number) => number, max: (...values: number[]) => number, min: (...values: number[]) => number, sin: (x: number) => number, tan: (x: number) => number, sqrt: (x: number) => number, pow: (x: number, y: number) => number, floor: (x: number) => number, ceil: (x: number) => number, random: () => number;
+export declare const abs: (x: number) => number, atan2: (y: number, x: number) => number, cos: (x: number) => number, max: (...values: number[]) => number, min: (...values: number[]) => number, sin: (x: number) => number, tan: (x: number) => number, sqrt: (x: number) => number, pow: (x: number, y: number) => number, floor: (x: number) => number, ceil: (x: number) => number, random: () => number, round: (x: number) => number;
 export declare const epsilon = 1e-12;
 export declare const pi: number;
 export declare const halfPi: number;

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

@@ -0,0 +1,4 @@
+import { ParsedThemeStyles, ThemeStyleOverrides } from '../models';
+export declare function parseThemeOptions(overrides?: ThemeStyleOverrides): ParsedThemeStyles;
+export declare function colorToHex(color: string): number;
+export declare function spacingToNumber(spacing: string): number;

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

@@ -7,6 +7,9 @@ export declare const intervals: {
 };
 export declare function secondsToString(input: number, showOnes?: boolean): string;
 export declare function secondsToApproximateString(input: number, showOnes?: boolean): string;
+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;

package/dist/types/src/workers/nodeLayout.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{viewport.es-975b1df9.mjs → viewport.es-bb25550c.mjs}

@@ -1,4 +1,4 @@
-import { P as c, R as b, T as C, C as P } from "./index-6ad35b53.mjs";
+import { P as c, R as b, T as C, C as P } from "./index-fc45ccf7.mjs";
 import "vue";
 class u {
   constructor(t) {
@@ -1530,4 +1530,4 @@ export {
   O as Viewport,
   $ as Wheel
 };
-//# sourceMappingURL=viewport.es-975b1df9.mjs.map
+//# sourceMappingURL=viewport.es-bb25550c.mjs.map