@genfeedai/workflow-ui 0.1.0

package/dist/chunk-CV4M7CNU.mjs

@@ -0,0 +1,251 @@
+import { create } from 'zustand';
+
+var usePromptEditorStore = create((set, get) => ({
+  isOpen: false,
+  nodeId: null,
+  prompt: "",
+  fontSize: 14,
+  openEditor: (nodeId, prompt) => {
+    set({
+      isOpen: true,
+      nodeId,
+      prompt
+    });
+  },
+  closeEditor: () => {
+    set({
+      isOpen: false,
+      nodeId: null,
+      prompt: ""
+    });
+  },
+  setPrompt: (prompt) => {
+    set({ prompt });
+  },
+  setFontSize: (fontSize) => {
+    set({ fontSize });
+  },
+  saveAndClose: () => {
+    const { nodeId, prompt } = get();
+    if (!nodeId) return null;
+    const result = { nodeId, prompt };
+    set({
+      isOpen: false,
+      nodeId: null,
+      prompt: ""
+    });
+    return result;
+  }
+}));
+var DEFAULT_TOOL_OPTIONS = {
+  strokeColor: "#ef4444",
+  // Red
+  strokeWidth: 3,
+  fillColor: null,
+  fontSize: 16
+};
+var shapeIdCounter = 0;
+function generateShapeId() {
+  return `shape-${Date.now()}-${++shapeIdCounter}`;
+}
+var useAnnotationStore = create((set, get) => ({
+  isOpen: false,
+  nodeId: null,
+  sourceImage: null,
+  shapes: [],
+  selectedShapeId: null,
+  currentTool: "rectangle",
+  toolOptions: DEFAULT_TOOL_OPTIONS,
+  history: [],
+  historyIndex: -1,
+  isDrawing: false,
+  drawingShape: null,
+  openAnnotation: (nodeId, image, existingShapes = []) => {
+    set({
+      isOpen: true,
+      nodeId,
+      sourceImage: image,
+      shapes: existingShapes,
+      selectedShapeId: null,
+      currentTool: "rectangle",
+      toolOptions: DEFAULT_TOOL_OPTIONS,
+      history: [existingShapes],
+      historyIndex: 0,
+      isDrawing: false,
+      drawingShape: null
+    });
+  },
+  closeAnnotation: () => {
+    set({
+      isOpen: false,
+      nodeId: null,
+      sourceImage: null,
+      shapes: [],
+      selectedShapeId: null,
+      history: [],
+      historyIndex: -1,
+      isDrawing: false,
+      drawingShape: null
+    });
+  },
+  saveAndClose: () => {
+    const { nodeId, shapes } = get();
+    if (!nodeId) return null;
+    const result = { nodeId, shapes: [...shapes] };
+    set({
+      isOpen: false,
+      nodeId: null,
+      sourceImage: null,
+      shapes: [],
+      selectedShapeId: null,
+      history: [],
+      historyIndex: -1,
+      isDrawing: false,
+      drawingShape: null
+    });
+    return result;
+  },
+  addShape: (shape) => {
+    set((state) => {
+      const newShapes = [...state.shapes, shape];
+      const newHistory = [...state.history.slice(0, state.historyIndex + 1), newShapes].slice(
+        -50
+      );
+      return {
+        shapes: newShapes,
+        history: newHistory,
+        historyIndex: newHistory.length - 1
+      };
+    });
+  },
+  updateShape: (id, updates) => {
+    set((state) => {
+      const newShapes = state.shapes.map(
+        (s) => s.id === id ? { ...s, ...updates } : s
+      );
+      const newHistory = [...state.history.slice(0, state.historyIndex + 1), newShapes].slice(
+        -50
+      );
+      return {
+        shapes: newShapes,
+        history: newHistory,
+        historyIndex: newHistory.length - 1
+      };
+    });
+  },
+  deleteShape: (id) => {
+    set((state) => {
+      const newShapes = state.shapes.filter((s) => s.id !== id);
+      const newHistory = [...state.history.slice(0, state.historyIndex + 1), newShapes].slice(
+        -50
+      );
+      return {
+        shapes: newShapes,
+        selectedShapeId: state.selectedShapeId === id ? null : state.selectedShapeId,
+        history: newHistory,
+        historyIndex: newHistory.length - 1
+      };
+    });
+  },
+  selectShape: (id) => {
+    set({ selectedShapeId: id });
+  },
+  clearShapes: () => {
+    set((state) => {
+      const newHistory = [...state.history.slice(0, state.historyIndex + 1), []].slice(
+        -50
+      );
+      return {
+        shapes: [],
+        selectedShapeId: null,
+        history: newHistory,
+        historyIndex: newHistory.length - 1
+      };
+    });
+  },
+  setTool: (tool) => {
+    set({ currentTool: tool, selectedShapeId: null });
+  },
+  setToolOptions: (options) => {
+    set((state) => ({
+      toolOptions: { ...state.toolOptions, ...options }
+    }));
+  },
+  startDrawing: (shape) => {
+    set({
+      isDrawing: true,
+      drawingShape: {
+        id: generateShapeId(),
+        ...shape
+      }
+    });
+  },
+  updateDrawing: (updates) => {
+    set((state) => ({
+      drawingShape: state.drawingShape ? { ...state.drawingShape, ...updates } : null
+    }));
+  },
+  finishDrawing: () => {
+    const { drawingShape, addShape } = get();
+    if (drawingShape && isValidShape(drawingShape)) {
+      addShape(drawingShape);
+    }
+    set({ isDrawing: false, drawingShape: null });
+  },
+  cancelDrawing: () => {
+    set({ isDrawing: false, drawingShape: null });
+  },
+  undo: () => {
+    set((state) => {
+      if (state.historyIndex > 0) {
+        const newIndex = state.historyIndex - 1;
+        return {
+          shapes: state.history[newIndex],
+          historyIndex: newIndex,
+          selectedShapeId: null
+        };
+      }
+      return state;
+    });
+  },
+  redo: () => {
+    set((state) => {
+      if (state.historyIndex < state.history.length - 1) {
+        const newIndex = state.historyIndex + 1;
+        return {
+          shapes: state.history[newIndex],
+          historyIndex: newIndex,
+          selectedShapeId: null
+        };
+      }
+      return state;
+    });
+  },
+  canUndo: () => {
+    const { historyIndex } = get();
+    return historyIndex > 0;
+  },
+  canRedo: () => {
+    const { historyIndex, history } = get();
+    return historyIndex < history.length - 1;
+  }
+}));
+function isValidShape(shape) {
+  if (!shape.id || !shape.type) return false;
+  switch (shape.type) {
+    case "rectangle":
+      return typeof shape.x === "number" && typeof shape.y === "number" && typeof shape.width === "number" && typeof shape.height === "number" && Math.abs(shape.width) > 5 && Math.abs(shape.height) > 5;
+    case "circle":
+      return typeof shape.x === "number" && typeof shape.y === "number" && typeof shape.radius === "number" && shape.radius > 5;
+    case "arrow":
+      return Array.isArray(shape.points) && shape.points.length >= 4 && Math.hypot(shape.points[2] - shape.points[0], shape.points[3] - shape.points[1]) > 10;
+    case "freehand":
+      return Array.isArray(shape.points) && shape.points.length >= 4;
+    case "text":
+      return typeof shape.x === "number" && typeof shape.y === "number" && typeof shape.text === "string" && shape.text.length > 0;
+    default:
+      return false;
+  }
+}
+
+export { useAnnotationStore, usePromptEditorStore };

package/dist/chunk-E323WAZG.mjs

@@ -0,0 +1,272 @@
+// src/lib/mediaExtraction.ts
+function getMediaFromNode(nodeType, data) {
+  switch (nodeType) {
+    case "imageGen": {
+      const imgData = data;
+      const urls = imgData.outputImages?.length ? imgData.outputImages : [];
+      return {
+        url: imgData.outputImage,
+        urls,
+        type: imgData.outputImage || urls.length ? "image" : null
+      };
+    }
+    case "videoGen": {
+      const vidData = data;
+      return { url: vidData.outputVideo, type: vidData.outputVideo ? "video" : null };
+    }
+    case "imageInput": {
+      const inputData = data;
+      return { url: inputData.image, type: inputData.image ? "image" : null };
+    }
+    case "videoInput": {
+      const vidInputData = data;
+      return { url: vidInputData.video, type: vidInputData.video ? "video" : null };
+    }
+    case "motionControl": {
+      const mcData = data;
+      return { url: mcData.outputVideo, type: mcData.outputVideo ? "video" : null };
+    }
+    case "download": {
+      const outData = data;
+      if (outData.inputVideo) {
+        return { url: outData.inputVideo, type: "video" };
+      }
+      if (outData.inputImage) {
+        return { url: outData.inputImage, type: "image" };
+      }
+      return { url: null, type: null };
+    }
+    default:
+      return { url: null, type: null };
+  }
+}
+
+// src/lib/schemaHandles.ts
+var HANDLE_FIELDS = /* @__PURE__ */ new Set([
+  // Text inputs
+  "prompt",
+  "negative_prompt",
+  "subject_reference",
+  // Image inputs (single)
+  "image",
+  "image_input",
+  "start_image",
+  "first_frame_image",
+  "end_image",
+  "last_frame",
+  "mask",
+  "mask_image",
+  "control_image",
+  "init_image",
+  "subject_image",
+  "face_image",
+  "style_image",
+  "pose_image",
+  "image_url",
+  "tail_image_url",
+  // Image inputs (array)
+  "reference_images",
+  // Video inputs
+  "video",
+  "video_url",
+  // Audio inputs
+  "audio",
+  "audio_url"
+]);
+var FIELD_TO_HANDLE_TYPE = {
+  // Text fields
+  prompt: "text",
+  negative_prompt: "text",
+  subject_reference: "text",
+  // Image fields (single)
+  image: "image",
+  image_input: "image",
+  start_image: "image",
+  first_frame_image: "image",
+  end_image: "image",
+  last_frame: "image",
+  mask: "image",
+  mask_image: "image",
+  control_image: "image",
+  init_image: "image",
+  subject_image: "image",
+  face_image: "image",
+  style_image: "image",
+  pose_image: "image",
+  image_url: "image",
+  tail_image_url: "image",
+  // Image fields (array)
+  reference_images: "image",
+  // Video fields
+  video: "video",
+  video_url: "video",
+  // Audio fields
+  audio: "audio",
+  audio_url: "audio"
+};
+function generateHandlesFromSchema(inputSchema, staticHandles) {
+  if (!inputSchema) return staticHandles;
+  const schema = inputSchema;
+  if (!schema.properties) return staticHandles;
+  const staticIds = new Set(staticHandles.map((h) => h.id));
+  const dynamicHandles = [];
+  for (const [fieldName, prop] of Object.entries(schema.properties)) {
+    if (!HANDLE_FIELDS.has(fieldName) || staticIds.has(fieldName)) continue;
+    const handleType = FIELD_TO_HANDLE_TYPE[fieldName];
+    if (!handleType) continue;
+    const label = prop.title || fieldName.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    dynamicHandles.push({
+      id: fieldName,
+      type: handleType,
+      label,
+      multiple: prop.type === "array",
+      required: schema.required?.includes(fieldName),
+      fromSchema: true
+    });
+  }
+  return [...staticHandles, ...dynamicHandles];
+}
+function isSchemaHandle(handle) {
+  return handle.fromSchema === true;
+}
+
+// src/lib/models/registry.ts
+var IMAGE_MODELS = [
+  { value: "nano-banana", label: "Nano Banana", apiId: "google/nano-banana" },
+  { value: "nano-banana-pro", label: "Nano Banana Pro", apiId: "google/nano-banana-pro" }
+];
+var IMAGE_MODEL_MAP = Object.fromEntries(
+  IMAGE_MODELS.map((m) => [m.apiId, m.value])
+);
+var IMAGE_MODEL_ID_MAP = Object.fromEntries(
+  IMAGE_MODELS.map((m) => [m.value, m.apiId])
+);
+var DEFAULT_IMAGE_MODEL = "nano-banana-pro";
+var VIDEO_MODELS = [
+  {
+    value: "veo-3.1-fast",
+    label: "Veo 3.1 Fast",
+    description: "Fast",
+    apiId: "google/veo-3.1-fast"
+  },
+  { value: "veo-3.1", label: "Veo 3.1", description: "High quality", apiId: "google/veo-3.1" }
+];
+var VIDEO_MODEL_MAP = Object.fromEntries(
+  VIDEO_MODELS.map((m) => [m.apiId, m.value])
+);
+var VIDEO_MODEL_ID_MAP = Object.fromEntries(
+  VIDEO_MODELS.map((m) => [m.value, m.apiId])
+);
+var DEFAULT_VIDEO_MODEL = "veo-3.1-fast";
+var LIPSYNC_MODELS = [
+  { value: "bytedance/omni-human", label: "OmniHuman (Image)", supportsImage: true },
+  { value: "veed/fabric-1.0", label: "VEED Fabric (Image)", supportsImage: true },
+  { value: "sync/lipsync-2-pro", label: "Sync Labs Pro (Video)", supportsImage: false },
+  { value: "sync/lipsync-2", label: "Sync Labs (Video)", supportsImage: false },
+  { value: "pixverse/lipsync", label: "Pixverse", supportsImage: true }
+];
+var LIPSYNC_SYNC_MODES = [
+  { value: "loop", label: "Loop" },
+  { value: "bounce", label: "Bounce" },
+  { value: "cut_off", label: "Cut Off" },
+  { value: "silence", label: "Silence" },
+  { value: "remap", label: "Remap" }
+];
+var DEFAULT_LIPSYNC_MODEL = "bytedance/omni-human";
+var LLM_MODELS = [
+  {
+    value: "meta-llama-3.1-405b-instruct",
+    label: "Llama 3.1 405B",
+    apiId: "meta/meta-llama-3.1-405b-instruct"
+  },
+  {
+    value: "claude-4.5-sonnet",
+    label: "Claude 4.5 Sonnet",
+    apiId: "anthropic/claude-4.5-sonnet"
+  }
+];
+var LLM_MODEL_MAP = Object.fromEntries(
+  LLM_MODELS.map((m) => [m.apiId, m.value])
+);
+var LLM_MODEL_ID_MAP = Object.fromEntries(
+  LLM_MODELS.map((m) => [m.value, m.apiId])
+);
+var DEFAULT_LLM_MODEL = "meta-llama-3.1-405b-instruct";
+function getImageModelLabel(model) {
+  return IMAGE_MODELS.find((m) => m.value === model)?.label ?? model;
+}
+function getVideoModelLabel(model) {
+  return VIDEO_MODELS.find((m) => m.value === model)?.label ?? model;
+}
+function getLipSyncModelLabel(model) {
+  return LIPSYNC_MODELS.find((m) => m.value === model)?.label ?? model;
+}
+function getLLMModelLabel(model) {
+  return LLM_MODELS.find((m) => m.value === model)?.label ?? model;
+}
+function lipSyncModelSupportsImage(model) {
+  return LIPSYNC_MODELS.find((m) => m.value === model)?.supportsImage ?? false;
+}
+
+// src/lib/easing.ts
+var EASING_PRESETS = {
+  // Linear - no easing
+  linear: [0, 0, 1, 1],
+  // Standard easing functions
+  easeIn: [0.42, 0, 1, 1],
+  easeOut: [0, 0, 0.58, 1],
+  easeInOut: [0.42, 0, 0.58, 1],
+  // Quadratic easing
+  easeInQuad: [0.55, 0.085, 0.68, 0.53],
+  easeOutQuad: [0.25, 0.46, 0.45, 0.94],
+  easeInOutQuad: [0.455, 0.03, 0.515, 0.955],
+  // Cubic easing
+  easeInCubic: [0.55, 0.055, 0.675, 0.19],
+  easeOutCubic: [0.215, 0.61, 0.355, 1],
+  easeInOutCubic: [0.645, 0.045, 0.355, 1],
+  // Exponential easing
+  easeInExpo: [0.95, 0.05, 0.795, 0.035],
+  easeOutExpo: [0.19, 1, 0.22, 1],
+  easeInOutExpo: [1, 0, 0, 1]
+};
+function evaluateBezier(t, curve) {
+  const [x1, y1, x2, y2] = curve;
+  const epsilon = 1e-6;
+  let guess = t;
+  for (let i = 0; i < 8; i++) {
+    const x = 3 * (1 - guess) * (1 - guess) * guess * x1 + 3 * (1 - guess) * guess * guess * x2 + guess * guess * guess - t;
+    if (Math.abs(x) < epsilon) break;
+    const dx = 3 * (1 - guess) * (1 - guess) * x1 + 6 * (1 - guess) * guess * (x2 - x1) + 3 * guess * guess * (1 - x2);
+    guess -= x / dx;
+  }
+  return 3 * (1 - guess) * (1 - guess) * guess * y1 + 3 * (1 - guess) * guess * guess * y2 + guess * guess * guess;
+}
+function applySpeedCurve(duration, curve, sampleRate = 60) {
+  const timestamps = [];
+  for (let i = 0; i <= sampleRate; i++) {
+    const t = i / sampleRate;
+    const easedT = evaluateBezier(t, curve);
+    timestamps.push(easedT * duration);
+  }
+  return timestamps;
+}
+function getEasingDisplayName(preset) {
+  const names = {
+    linear: "Linear",
+    easeIn: "Ease In",
+    easeOut: "Ease Out",
+    easeInOut: "Ease In Out",
+    easeInQuad: "Ease In Quadratic",
+    easeOutQuad: "Ease Out Quadratic",
+    easeInOutQuad: "Ease In Out Quadratic",
+    easeInCubic: "Ease In Cubic",
+    easeOutCubic: "Ease Out Cubic",
+    easeInOutCubic: "Ease In Out Cubic",
+    easeInExpo: "Ease In Exponential",
+    easeOutExpo: "Ease Out Exponential",
+    easeInOutExpo: "Ease In Out Exponential"
+  };
+  return names[preset] || preset;
+}
+
+export { DEFAULT_IMAGE_MODEL, DEFAULT_LIPSYNC_MODEL, DEFAULT_LLM_MODEL, DEFAULT_VIDEO_MODEL, EASING_PRESETS, IMAGE_MODELS, IMAGE_MODEL_ID_MAP, IMAGE_MODEL_MAP, LIPSYNC_MODELS, LIPSYNC_SYNC_MODES, LLM_MODELS, LLM_MODEL_ID_MAP, LLM_MODEL_MAP, VIDEO_MODELS, VIDEO_MODEL_ID_MAP, VIDEO_MODEL_MAP, applySpeedCurve, evaluateBezier, generateHandlesFromSchema, getEasingDisplayName, getImageModelLabel, getLLMModelLabel, getLipSyncModelLabel, getMediaFromNode, getVideoModelLabel, isSchemaHandle, lipSyncModelSupportsImage };