@genfeedai/workflow-ui 0.1.2 → 0.1.4

package/dist/lib.d.mts

@@ -1,4 +1,6 @@
-import { HandleDefinition, NodeType, WorkflowNodeData, EasingPreset, CubicBezier, ImageModel, VideoModel, LipSyncModel, TextModel } from '@genfeedai/types';
+import { HandleDefinition, NodeType, WorkflowNodeData, EasingPreset, CubicBezier, WorkflowNode, ImageModel, VideoModel, LipSyncModel, TextModel } from '@genfeedai/types';
+import * as react from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 
 /**
  * Generates dynamic input handles from a model's input schema.
@@ -70,7 +72,7 @@ declare function getMediaFromNode(nodeType: NodeType, data: WorkflowNodeData): M
 /**
  * Get the dimensions of an image from its source URL or data URL.
  */
-declare function getImageDimensions(src: string): Promise<{
+declare function getImageDimensions$1(src: string): Promise<{
     width: number;
     height: number;
 }>;
@@ -85,11 +87,68 @@ declare function getVideoMetadata(src: string): Promise<{
     };
 }>;
 
+type EasingFunction = (t: number) => number;
 /**
  * Easing presets based on easy-peasy-ease patterns
  * Each preset is a cubic bezier curve: [x1, y1, x2, y2]
  */
 declare const EASING_PRESETS: Record<EasingPreset, CubicBezier>;
+declare const DEFAULT_CUSTOM_BEZIER: CubicBezier;
+/** Named presets for the CubicBezierEditor */
+declare const PRESET_BEZIERS: {
+    readonly easeInExpoOutCubic: [0.85, 0, 0.15, 1];
+    readonly easeInOutExpo: [0.87, 0, 0.13, 1];
+    readonly easeInQuartOutQuad: [0.8, 0, 0.2, 1];
+    readonly easeInOutCubic: [0.65, 0, 0.35, 1];
+    readonly easeInOutSine: [0.37, 0, 0.63, 1];
+};
+type EasingPresetName = keyof typeof PRESET_BEZIERS;
+/**
+ * Full bezier map covering all standard easings from easings.net.
+ * Hybrid easings (easeInExpoOutCubic, easeInQuartOutQuad) are approximations
+ * since asymmetric compositions can't be exactly represented by a single cubic bezier.
+ */
+declare const EASING_BEZIER_MAP: Record<string, CubicBezier>;
+/** Look up a preset bezier from PRESET_BEZIERS by name */
+declare function getPresetBezier(preset?: string | null): CubicBezier;
+/** Look up any easing bezier from the full EASING_BEZIER_MAP */
+declare function getEasingBezier(name?: string | null): CubicBezier;
+declare function createAsymmetricEase(easeIn: EasingFunction, easeOut: EasingFunction): EasingFunction;
+/** All parametric easing functions (22 base + 2 hybrids) */
+declare const easing: {
+    readonly easeInExpoOutCubic: EasingFunction;
+    readonly easeInQuartOutQuad: EasingFunction;
+    readonly linear: (t: number) => number;
+    readonly easeInQuad: (t: number) => number;
+    readonly easeOutQuad: (t: number) => number;
+    readonly easeInOutQuad: (t: number) => number;
+    readonly easeInCubic: (t: number) => number;
+    readonly easeOutCubic: (t: number) => number;
+    readonly easeInOutCubic: (t: number) => number;
+    readonly easeInQuart: (t: number) => number;
+    readonly easeOutQuart: (t: number) => number;
+    readonly easeInOutQuart: (t: number) => number;
+    readonly easeInQuint: (t: number) => number;
+    readonly easeOutQuint: (t: number) => number;
+    readonly easeInOutQuint: (t: number) => number;
+    readonly easeInSine: (t: number) => number;
+    readonly easeOutSine: (t: number) => number;
+    readonly easeInOutSine: (t: number) => number;
+    readonly easeInExpo: (t: number) => number;
+    readonly easeOutExpo: (t: number) => number;
+    readonly easeInOutExpo: (t: number) => number;
+    readonly easeInCirc: (t: number) => number;
+    readonly easeOutCirc: (t: number) => number;
+    readonly easeInOutCirc: (t: number) => number;
+};
+/**
+ * Create an easing function from cubic bezier control points
+ */
+declare function createBezierEasing(p1x: number, p1y: number, p2x: number, p2y: number): EasingFunction;
+/** Resolve easing function by name */
+declare function getEasingFunction(name: string): EasingFunction;
+/** List all available easing function names */
+declare function getAllEasingNames(): string[];
 /**
  * Evaluate a cubic bezier curve at parameter t
  */
@@ -102,7 +161,194 @@ declare function applySpeedCurve(duration: number, curve: CubicBezier, sampleRat
 /**
  * Get display name for easing preset
  */
-declare function getEasingDisplayName(preset: EasingPreset): string;
+declare function getEasingDisplayName(preset: EasingPreset | string): string;
+
+/**
+ * Speed Curve Utility
+ *
+ * Advanced time-warping for video speed ramps using easing functions.
+ * Maps original video timestamps to warped timestamps through easing curves.
+ */
+
+/**
+ * Maps original video timestamps to warped timestamps using any easing function.
+ *
+ * @param originalTime - Original timestamp in seconds (0 to inputDuration)
+ * @param inputDuration - Input video duration in seconds (default: 5)
+ * @param outputDuration - Output video duration in seconds (default: 1.5)
+ * @param easingFunction - Easing function or function name string (default: easeInOutCubic)
+ * @returns Warped timestamp for the output video
+ */
+declare function warpTime(originalTime: number, inputDuration?: number, outputDuration?: number, easingFunction?: EasingFunction | string): number;
+/**
+ * Calculate the duration of a frame after warping.
+ */
+declare function calculateWarpedDuration(originalStart: number, originalDuration: number, inputDuration?: number, outputDuration?: number, easingFunction?: EasingFunction | string): number;
+/**
+ * Validate that a warp time function produces valid output.
+ */
+declare function validateWarpFunction(easingFunction?: EasingFunction | string, inputDuration?: number, outputDuration?: number, tolerance?: number): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Generate statistics about the warp curve.
+ */
+declare function analyzeWarpCurve(easingFunction?: EasingFunction | string, inputDuration?: number, outputDuration?: number, samples?: number): {
+    speedMultipliers: number[];
+    minSpeed: number;
+    maxSpeed: number;
+    avgSpeed: number;
+};
+
+/**
+ * Grid Splitter Utility
+ *
+ * Detects and splits contact sheet grids into component images.
+ * Uses a regularity-first approach that assumes grids are uniform,
+ * scoring candidates based on how well the image dimensions divide
+ * into cells with common photo aspect ratios.
+ */
+interface GridCell {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface GridDetectionResult {
+    rows: number;
+    cols: number;
+    cells: GridCell[];
+    confidence: number;
+}
+interface GridCandidate {
+    rows: number;
+    cols: number;
+    cellWidth: number;
+    cellHeight: number;
+    cellAspectRatio: number;
+    score: number;
+}
+/**
+ * Analyzes an image and detects grid boundaries.
+ */
+declare function detectGrid(imageDataUrl: string): Promise<GridDetectionResult>;
+/**
+ * Creates a grid result for a specific rows x cols configuration.
+ */
+declare function createGridForDimensions(width: number, height: number, rows: number, cols: number): GridDetectionResult;
+/**
+ * Detects grid with user-specified dimensions (most reliable).
+ */
+declare function detectGridWithDimensions(imageDataUrl: string, rows: number, cols: number): Promise<GridDetectionResult>;
+/**
+ * Gets ranked grid candidates based on geometric analysis.
+ */
+declare function getGridCandidates(width: number, height: number): GridCandidate[];
+/**
+ * Splits an image into grid cells and returns them as separate data URLs.
+ */
+declare function splitImage(imageDataUrl: string, grid: GridDetectionResult): Promise<string[]>;
+/**
+ * Convenience function that detects and splits in one call.
+ */
+declare function detectAndSplitGrid(imageDataUrl: string): Promise<{
+    grid: GridDetectionResult;
+    images: string[];
+}>;
+/**
+ * Split with user-specified dimensions (most reliable method).
+ */
+declare function splitWithDimensions(imageDataUrl: string, rows: number, cols: number): Promise<{
+    grid: GridDetectionResult;
+    images: string[];
+}>;
+
+/**
+ * Node Dimensions Utility
+ *
+ * Calculate node dimensions based on output aspect ratio,
+ * respecting min/max constraints.
+ */
+/**
+ * Extract dimensions from a base64 data URL image.
+ */
+declare function getImageDimensions(base64DataUrl: string): Promise<{
+    width: number;
+    height: number;
+} | null>;
+/**
+ * Extract dimensions from a video data URL or blob URL.
+ */
+declare function getVideoDimensions(videoUrl: string): Promise<{
+    width: number;
+    height: number;
+} | null>;
+/**
+ * Calculate node dimensions that maintain aspect ratio within constraints.
+ *
+ * @param aspectRatio - Width divided by height (e.g., 16/9 for landscape)
+ * @param baseWidth - Starting width to calculate from (default 300px)
+ */
+declare function calculateNodeSize(aspectRatio: number, baseWidth?: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Calculate node dimensions preserving current height if provided.
+ *
+ * @param aspectRatio - Width divided by height
+ * @param currentHeight - Optional current height to preserve (if within constraints)
+ */
+declare function calculateNodeSizePreservingHeight(aspectRatio: number, currentHeight?: number): {
+    width: number;
+    height: number;
+};
+
+/**
+ * Deduplicated Fetch Utility
+ *
+ * When multiple callers request the same URL concurrently, only one
+ * actual network request is made. All callers receive the same response
+ * data once the request completes. Responses are cached for 5 seconds.
+ */
+/**
+ * Fetch with request deduplication.
+ *
+ * Multiple concurrent calls to the same URL (with same headers) will
+ * share a single network request. The response is cloned for each caller.
+ */
+declare function deduplicatedFetch(url: string, options?: RequestInit): Promise<Response>;
+/**
+ * Clear all cached responses.
+ */
+declare function clearFetchCache(): void;
+
+interface NodeCostEstimate {
+    nodeId: string;
+    nodeLabel: string;
+    nodeType: string;
+    model: string;
+    unit: string;
+    cost: number;
+}
+interface CostBreakdown {
+    total: number;
+    nodes: NodeCostEstimate[];
+}
+declare function calculateWorkflowCost(nodes: WorkflowNode[]): CostBreakdown;
+declare function formatCost(amount: number): string;
+
+interface CubicBezierEditorProps {
+    value: CubicBezier;
+    onChange: (value: CubicBezier) => void;
+    onCommit?: (value: CubicBezier) => void;
+    disabled?: boolean;
+    width?: number;
+    height?: number;
+}
+declare function CubicBezierEditorComponent({ value, onChange, onCommit, disabled, width, height, }: CubicBezierEditorProps): react_jsx_runtime.JSX.Element;
+declare const CubicBezierEditor: react.MemoExoticComponent<typeof CubicBezierEditorComponent>;
 
 interface ImageModelConfig {
     value: ImageModel;
@@ -161,4 +407,4 @@ declare function getLipSyncModelLabel(model: LipSyncModel): string;
 declare function getLLMModelLabel(model: TextModel): string;
 declare function lipSyncModelSupportsImage(model: LipSyncModel): boolean;
 
-export { CONNECTION_FIELDS, DEFAULT_IMAGE_MODEL, DEFAULT_LIPSYNC_MODEL, DEFAULT_LLM_MODEL, DEFAULT_VIDEO_MODEL, EASING_PRESETS, IMAGE_MODELS, IMAGE_MODEL_ID_MAP, IMAGE_MODEL_MAP, type ImageModelConfig, LIPSYNC_MODELS, LIPSYNC_SYNC_MODES, LLM_MODELS, LLM_MODEL_ID_MAP, LLM_MODEL_MAP, type LipSyncModelConfig, type MediaInfo, type TextModelConfig, VIDEO_MODELS, VIDEO_MODEL_ID_MAP, VIDEO_MODEL_MAP, type VideoModelConfig, applySpeedCurve, evaluateBezier, extractEnumValues, generateHandlesFromSchema, getEasingDisplayName, getImageDimensions, getImageModelLabel, getLLMModelLabel, getLipSyncModelLabel, getMediaFromNode, getSchemaDefaults, getVideoMetadata, getVideoModelLabel, isSchemaHandle, lipSyncModelSupportsImage, supportsImageInput, validateRequiredSchemaFields };
+export { CONNECTION_FIELDS, type CostBreakdown, CubicBezierEditor, DEFAULT_CUSTOM_BEZIER, DEFAULT_IMAGE_MODEL, DEFAULT_LIPSYNC_MODEL, DEFAULT_LLM_MODEL, DEFAULT_VIDEO_MODEL, EASING_BEZIER_MAP, EASING_PRESETS, type EasingFunction, type EasingPresetName, type GridCandidate, type GridCell, type GridDetectionResult, IMAGE_MODELS, IMAGE_MODEL_ID_MAP, IMAGE_MODEL_MAP, type ImageModelConfig, LIPSYNC_MODELS, LIPSYNC_SYNC_MODES, LLM_MODELS, LLM_MODEL_ID_MAP, LLM_MODEL_MAP, type LipSyncModelConfig, type MediaInfo, type NodeCostEstimate, PRESET_BEZIERS, type TextModelConfig, VIDEO_MODELS, VIDEO_MODEL_ID_MAP, VIDEO_MODEL_MAP, type VideoModelConfig, analyzeWarpCurve, applySpeedCurve, calculateNodeSize, calculateNodeSizePreservingHeight, calculateWarpedDuration, calculateWorkflowCost, clearFetchCache, createAsymmetricEase, createBezierEasing, createGridForDimensions, deduplicatedFetch, detectAndSplitGrid, detectGrid, detectGridWithDimensions, easing, evaluateBezier, extractEnumValues, formatCost, generateHandlesFromSchema, getAllEasingNames, getEasingBezier, getEasingDisplayName, getEasingFunction, getGridCandidates, getImageDimensions$1 as getImageDimensions, getImageDimensions as getImageDimensionsFromDataUrl, getImageModelLabel, getLLMModelLabel, getLipSyncModelLabel, getMediaFromNode, getPresetBezier, getSchemaDefaults, getVideoDimensions as getVideoDimensionsFromUrl, getVideoMetadata, getVideoModelLabel, isSchemaHandle, lipSyncModelSupportsImage, splitImage, splitWithDimensions, supportsImageInput, validateRequiredSchemaFields, validateWarpFunction, warpTime };