ugcinc 4.1.21 → 4.1.23

package/dist/nodes/video-composer.d.ts

@@ -1,3 +0,0 @@
-import type { NodeDefinition } from '../types';
-declare const definition: NodeDefinition;
-export default definition;

package/dist/nodes/video-composer.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const definition = {
-    nodeId: 'video-composer',
-    label: 'Video Composer',
-    description: 'Create templated videos',
-    type: 'generator',
-    category: 'Generation',
-    getDefaultConfig: () => ({
-        videoEditor: {
-            width: 1080,
-            height: 1920,
-            fps: 30,
-            dimensionPreset: '9:16',
-            channels: [{
-                    id: 'main-track',
-                    name: 'Main Track',
-                    segments: [],
-                }],
-        },
-        outputMode: 'per-input',
-    }),
-    computePorts: ({ config }) => {
-        const editorConfig = config?.videoEditor;
-        const inputs = [];
-        const addedIds = new Set();
-        if (editorConfig) {
-            editorConfig.channels.forEach(channel => {
-                channel.segments.forEach(segment => {
-                    if (segment.inputRef && !addedIds.has(segment.inputRef)) {
-                        addedIds.add(segment.inputRef);
-                        const inputType = segment.type === 'video' ? 'video'
-                            : segment.type === 'audio' ? 'audio'
-                                : 'image';
-                        inputs.push({
-                            id: segment.inputRef,
-                            type: inputType,
-                            isArray: false,
-                            required: segment.required ?? true,
-                        });
-                    }
-                    if (segment.textInputRef && !addedIds.has(segment.textInputRef)) {
-                        addedIds.add(segment.textInputRef);
-                        inputs.push({
-                            id: segment.textInputRef,
-                            type: 'text',
-                            isArray: false,
-                            required: segment.required ?? true,
-                        });
-                    }
-                });
-            });
-        }
-        return {
-            inputs,
-            outputs: [
-                {
-                    id: 'output',
-                    type: 'video',
-                    isArray: false,
-                    required: true,
-                },
-            ],
-        };
-    },
-};
-exports.default = definition;

package/dist/nodes/video-import.d.ts

@@ -1,3 +0,0 @@
-import type { NodeDefinition } from '../types';
-declare const definition: NodeDefinition;
-export default definition;

package/dist/nodes/video-import.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const definition = {
-    nodeId: 'video-import',
-    label: 'Import Video',
-    description: 'Import videos from YouTube, TikTok, Instagram & more',
-    type: 'source',
-    category: 'Sources',
-    getDefaultConfig: () => ({
-        videoImportConfig: {
-            platform: 'youtube',
-            videoQuality: '1080',
-        },
-        outputMode: 'per-input',
-    }),
-    computePorts: () => ({
-        inputs: [
-            {
-                id: 'url',
-                type: 'text',
-                isArray: false,
-                required: true,
-            },
-        ],
-        outputs: [
-            {
-                id: 'video',
-                type: 'video',
-                isArray: false,
-                required: true,
-            },
-        ],
-    }),
-};
-exports.default = definition;

package/dist/ports.d.ts

@@ -1,54 +0,0 @@
-/**
- * Port computation utilities for automation nodes
- *
- * These functions dynamically compute input and output ports for nodes
- * based on their type and configuration. Used by both webapp (for UI rendering)
- * and API (for validation and execution).
- */
-import type { PortType, NodeTypeEnum, PropertySchema } from './types';
-/**
- * Computed port definition
- */
-export interface ComputedPort {
-    id: string;
-    type: PortType | PortType[];
-    required: boolean;
-    itemSchema?: Record<string, PropertySchema>;
-}
-/**
- * Extract template variables from text (e.g., "Hello {{name}}" -> ["name"])
- */
-export declare function extractTemplateVariables(texts: string[]): string[];
-/**
- * Minimal node interface for port computation
- * Allows both WorkflowNodeDefinition and webapp's Node type to be used
- */
-interface NodeLike {
-    id: string;
-    type: NodeTypeEnum;
-    config?: Record<string, unknown>;
-}
-/**
- * Compute the input ports for a node based on its type and config
- */
-export declare function computeInputPorts({ node }: {
-    node: NodeLike;
-}): ComputedPort[];
-/**
- * Compute the output ports for a node based on its type and config
- *
- * Uses resolvedPorts as the primary source of truth - modals save complete
- * port definitions to resolvedPorts when the node is configured.
- * Falls back to static outputs from getAllNodes() for nodes without dynamic ports.
- */
-export declare function computeOutputPorts({ node }: {
-    node: NodeLike;
-}): ComputedPort[];
-/**
- * Check if an input port is required for a given node.
- */
-export declare function isInputPortRequired({ node, portId, }: {
-    node: NodeLike;
-    portId: string;
-}): boolean;
-export {};

package/dist/ports.js

@@ -1,327 +0,0 @@
-"use strict";
-/**
- * Port computation utilities for automation nodes
- *
- * These functions dynamically compute input and output ports for nodes
- * based on their type and configuration. Used by both webapp (for UI rendering)
- * and API (for validation and execution).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractTemplateVariables = extractTemplateVariables;
-exports.computeInputPorts = computeInputPorts;
-exports.computeOutputPorts = computeOutputPorts;
-exports.isInputPortRequired = isInputPortRequired;
-const types_1 = require("./types");
-const automations_1 = require("./automations");
-/**
- * Extract template variables from text (e.g., "Hello {{name}}" -> ["name"])
- */
-function extractTemplateVariables(texts) {
-    const variables = new Set();
-    const regex = /\{\{(\w+)\}\}/g;
-    for (const text of texts) {
-        let match;
-        while ((match = regex.exec(text)) !== null) {
-            if (match[1])
-                variables.add(match[1]);
-        }
-    }
-    return Array.from(variables);
-}
-/**
- * Compute the input ports for a node based on its type and config
- */
-function computeInputPorts({ node }) {
-    const nodeConfigs = (0, automations_1.getAllNodes)();
-    const nodeConfig = nodeConfigs.find(n => n.nodeId === node.type);
-    const baseInputs = nodeConfig?.inputs ?? [];
-    // Text nodes: generate inputs from template variables
-    if (node.type === 'text') {
-        const textOptions = (node.config?.textOptions ?? []);
-        const variables = extractTemplateVariables(textOptions);
-        if (variables.length === 0)
-            return baseInputs;
-        return variables.map(variable => ({
-            id: variable,
-            type: (0, types_1.portType)({ type: 'text', isArray: false }),
-            required: false,
-        }));
-    }
-    // Image-editor nodes: generate inputs from elements
-    if (node.type === 'image-composer') {
-        const editorConfig = node.config?.imageEditor;
-        if (!editorConfig)
-            return baseInputs;
-        const dynamicInputs = [];
-        // Only add background input if backgroundType is 'image'
-        if (editorConfig.backgroundType !== 'color') {
-            dynamicInputs.push({
-                id: 'background',
-                type: (0, types_1.portType)({ type: 'image', isArray: false }),
-                required: true,
-            });
-        }
-        // Add inputs for each element that has an inputId or textInputId
-        editorConfig.elements.forEach(elem => {
-            if (elem.type === 'image' && elem.inputId) {
-                dynamicInputs.push({
-                    id: elem.inputId,
-                    type: (0, types_1.portType)({ type: 'image', isArray: false }),
-                    required: true,
-                });
-            }
-            else if (elem.type === 'text' && elem.textInputId) {
-                dynamicInputs.push({
-                    id: elem.textInputId,
-                    type: (0, types_1.portType)({ type: 'text', isArray: false }),
-                    required: true,
-                });
-            }
-        });
-        // Add crop boundary inputs (not required)
-        const addedCropInputs = new Set();
-        const cropConfig = editorConfig.dynamicCrop;
-        [
-            cropConfig?.vertical?.startBoundary?.inputRef,
-            cropConfig?.vertical?.endBoundary?.inputRef,
-            cropConfig?.horizontal?.startBoundary?.inputRef,
-            cropConfig?.horizontal?.endBoundary?.inputRef,
-        ].forEach(inputRef => {
-            if (inputRef && !addedCropInputs.has(inputRef)) {
-                addedCropInputs.add(inputRef);
-                dynamicInputs.push({
-                    id: inputRef,
-                    type: (0, types_1.portType)({ type: 'text', isArray: false }),
-                    required: false,
-                });
-            }
-        });
-        return dynamicInputs;
-    }
-    // Video-editor nodes: generate inputs from segments
-    if (node.type === 'video-composer') {
-        const editorConfig = node.config?.videoEditor;
-        if (!editorConfig)
-            return [];
-        const dynamicInputs = [];
-        const addedIds = new Set();
-        editorConfig.channels.forEach(channel => {
-            channel.segments.forEach(segment => {
-                if ('inputRef' in segment && segment.inputRef && !addedIds.has(segment.inputRef)) {
-                    addedIds.add(segment.inputRef);
-                    const inputType = segment.type === 'video' ? (0, types_1.portType)({ type: 'video', isArray: false })
-                        : segment.type === 'audio' ? (0, types_1.portType)({ type: 'audio', isArray: false })
-                            : (0, types_1.portType)({ type: 'image', isArray: false });
-                    dynamicInputs.push({
-                        id: segment.inputRef,
-                        type: inputType,
-                        required: true,
-                    });
-                }
-                if ('textInputRef' in segment && segment.textInputRef && !addedIds.has(segment.textInputRef)) {
-                    addedIds.add(segment.textInputRef);
-                    dynamicInputs.push({
-                        id: segment.textInputRef,
-                        type: (0, types_1.portType)({ type: 'text', isArray: false }),
-                        required: true,
-                    });
-                }
-            });
-        });
-        return dynamicInputs;
-    }
-    // Workflow nodes: generate inputs from embedded workflow's variable nodes
-    if (node.type === 'compose-workflow') {
-        const variableNodes = node.config?.workflowVariableNodes;
-        if (!variableNodes || variableNodes.length === 0)
-            return baseInputs;
-        return variableNodes.map(v => {
-            const varType = v.variableType === 'dropdown' ? 'text' : (v.variableType ?? 'text');
-            return {
-                id: v.id,
-                type: (0, types_1.portType)({ type: varType, isArray: false }),
-                required: false,
-            };
-        });
-    }
-    // Output nodes: generate inputs from outputConfig.inputs
-    if (node.type === 'output') {
-        const outputConfig = node.config?.outputConfig;
-        const configInputs = outputConfig?.inputs;
-        if (!configInputs || configInputs.length === 0)
-            return baseInputs;
-        return configInputs.map((input) => ({
-            id: input.id,
-            type: (0, types_1.portType)({ type: input.type, isArray: input.isArray ?? false }),
-            required: false,
-        }));
-    }
-    // Auto-post nodes: video or slideshow mode
-    if (node.type === 'auto-post') {
-        const autoPostConfig = node.config?.autoPostConfig;
-        const mode = autoPostConfig?.mode ?? 'video';
-        const dynamicInputs = [];
-        if (mode === 'video') {
-            // Video mode: video input required
-            dynamicInputs.push({ id: 'video', type: (0, types_1.portType)({ type: 'video', isArray: false }), required: true });
-        }
-        else {
-            // Slideshow mode
-            const inputType = autoPostConfig?.inputType ?? 'static';
-            if (inputType === 'variable') {
-                // Variable mode: single images array port
-                dynamicInputs.push({ id: 'images', type: (0, types_1.portType)({ type: 'object', isArray: false }), required: true });
-            }
-            else {
-                // Static mode: individual image inputs
-                const imageInputs = autoPostConfig?.inputs ?? [
-                    { id: 'image1' },
-                    { id: 'image2' },
-                    { id: 'image3' },
-                ];
-                imageInputs.forEach((input) => {
-                    dynamicInputs.push({ id: input.id, type: (0, types_1.portType)({ type: 'image', isArray: false }), required: true });
-                });
-            }
-        }
-        // Add static inputs (same for both modes)
-        dynamicInputs.push({ id: 'account', type: (0, types_1.portType)({ type: 'account', isArray: false }), required: true }, { id: 'caption', type: (0, types_1.portType)({ type: 'text', isArray: false }), required: false });
-        // Only add social-audio port if isVariable is true
-        if (autoPostConfig?.socialAudio?.isVariable) {
-            dynamicInputs.push({ id: 'social-audio', type: (0, types_1.portType)({ type: 'audio', isArray: false }), required: false });
-        }
-        return dynamicInputs;
-    }
-    // Save-to-media nodes: generate inputs from saveToMediaConfig.inputs
-    if (node.type === 'save-to-media') {
-        const saveConfig = node.config?.saveToMediaConfig;
-        const configInputs = saveConfig?.inputs;
-        if (!configInputs || configInputs.length === 0)
-            return baseInputs;
-        return configInputs.map((input) => ({
-            id: input.id,
-            type: (0, types_1.portType)({ type: input.type, isArray: false }),
-            required: true,
-        }));
-    }
-    // LLM nodes: generate inputs from systemPrompt variables + media refs
-    if (node.type === 'llm') {
-        const llmConfig = node.config?.llm;
-        const dynamicInputs = [];
-        // Extract {{variables}} from systemPrompt
-        // Variable inputs accept text, object (for JSON data), and boolean types
-        const systemPrompt = llmConfig?.systemPrompt ?? '';
-        const variables = extractTemplateVariables([systemPrompt]);
-        variables.forEach(v => dynamicInputs.push({
-            id: v,
-            type: [(0, types_1.portType)({ type: 'text', isArray: false }), (0, types_1.portType)({ type: 'object', isArray: false }), (0, types_1.portType)({ type: 'boolean', isArray: false })],
-            required: true,
-        }));
-        // Add image input refs
-        llmConfig?.imageInputRefs?.forEach((ref) => dynamicInputs.push({ id: ref, type: (0, types_1.portType)({ type: 'image', isArray: false }), required: true }));
-        // Add video input refs
-        llmConfig?.videoInputRefs?.forEach((ref) => dynamicInputs.push({ id: ref, type: (0, types_1.portType)({ type: 'video', isArray: false }), required: true }));
-        return dynamicInputs.length > 0 ? dynamicInputs : baseInputs;
-    }
-    // For-each nodes: array input + passthrough inputs
-    if (node.type === 'for-each') {
-        const forEachConfig = node.config?.forEachConfig;
-        const inputPorts = forEachConfig?.inputPorts ?? [];
-        return [
-            { id: 'array', type: (0, types_1.portType)({ type: 'object', isArray: false }), required: true },
-            ...inputPorts.map((port) => ({
-                id: port.id,
-                type: (0, types_1.portType)({ type: port.type, isArray: port.isArray ?? false }),
-                required: false,
-            })),
-        ];
-    }
-    // If nodes: boolean inputs + passthrough inputs from resolvedPorts
-    if (node.type === 'if') {
-        const resolvedPorts = node.config?.resolvedPorts;
-        if (resolvedPorts?.inputs && resolvedPorts.inputs.length > 0) {
-            return resolvedPorts.inputs.map(port => ({
-                id: port.id,
-                type: port.type,
-                required: port.required,
-            }));
-        }
-        return baseInputs;
-    }
-    // Transcript nodes: media input
-    if (node.type === 'transcript') {
-        return [{ id: 'media', type: [(0, types_1.portType)({ type: 'video', isArray: false }), (0, types_1.portType)({ type: 'audio', isArray: false })], required: true }];
-    }
-    // Video import nodes: url input
-    if (node.type === 'video-import') {
-        return [{ id: 'url', type: (0, types_1.portType)({ type: 'text', isArray: false }), required: true }];
-    }
-    // Image Generation nodes: prompt + optional image for edit models
-    if (node.type === 'generate-image') {
-        const imageGenConfig = node.config?.imageGeneration;
-        const model = imageGenConfig?.model ?? '';
-        const isEditModel = model.includes('/edit');
-        const dynamicInputs = [
-            { id: 'prompt', type: (0, types_1.portType)({ type: 'text', isArray: false }), required: true },
-        ];
-        if (isEditModel) {
-            dynamicInputs.push({ id: 'image', type: (0, types_1.portType)({ type: 'image', isArray: false }), required: true });
-        }
-        return dynamicInputs;
-    }
-    // Custom Model nodes: generate inputs from inputParams
-    if (node.type === 'custom-model') {
-        const customModelConfig = node.config?.customModelConfig;
-        const inputParams = customModelConfig?.inputParams ?? [];
-        const dynamicInputs = [];
-        inputParams.forEach((param) => {
-            if (param.name === 'prompt' || param.type === 'image' || param.type === 'video' || param.type === 'audio') {
-                const pType = (param.type === 'image' || param.type === 'video' || param.type === 'audio')
-                    ? param.type
-                    : 'text';
-                dynamicInputs.push({
-                    id: param.name,
-                    type: (0, types_1.portType)({ type: pType, isArray: false }),
-                    required: param.required,
-                });
-            }
-        });
-        return dynamicInputs;
-    }
-    // Deduplicate nodes: video input
-    if (node.type === 'deduplicate') {
-        return [{ id: 'video', type: (0, types_1.portType)({ type: 'video', isArray: false }), required: true }];
-    }
-    return baseInputs;
-}
-/**
- * Compute the output ports for a node based on its type and config
- *
- * Uses resolvedPorts as the primary source of truth - modals save complete
- * port definitions to resolvedPorts when the node is configured.
- * Falls back to static outputs from getAllNodes() for nodes without dynamic ports.
- */
-function computeOutputPorts({ node }) {
-    // Primary: use resolvedPorts if available (computed by modal)
-    const resolvedPorts = node.config?.resolvedPorts;
-    if (resolvedPorts?.outputs && resolvedPorts.outputs.length > 0) {
-        return resolvedPorts.outputs.map(port => ({
-            id: port.id,
-            type: port.type,
-            required: port.required,
-            itemSchema: port.itemSchema,
-        }));
-    }
-    // Fallback: use static outputs from getAllNodes() for nodes without dynamic ports
-    const nodeConfigs = (0, automations_1.getAllNodes)();
-    const nodeConfig = nodeConfigs.find(n => n.nodeId === node.type);
-    return nodeConfig?.outputs ?? [];
-}
-/**
- * Check if an input port is required for a given node.
- */
-function isInputPortRequired({ node, portId, }) {
-    const ports = computeInputPorts({ node });
-    const port = ports.find(p => p.id === portId);
-    return port?.required ?? true; // Default to required for safety
-}