ugcinc 4.0.2 → 4.1.1

package/dist/automations/nodes/for-each.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'for-each',
+    label: 'For Each',
+    description: 'Iterate over an array, executing downstream nodes for each item',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        outputProperties: [],
+        inputPorts: [],
+        exposeItem: false,
+        exposeIndex: false,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config, getConnectedOutput }) => {
+        const outputProperties = config?.outputProperties ?? [];
+        const inputPorts = config?.inputPorts ?? [];
+        const exposeItem = config?.exposeItem ?? false;
+        const exposeIndex = config?.exposeIndex ?? false;
+        // Inputs: array + passthrough inputs
+        const inputs = [
+            { id: 'array', type: 'object', isArray: false, required: true },
+        ];
+        for (const port of inputPorts) {
+            inputs.push({
+                id: port.id,
+                type: port.type,
+                isArray: port.isArray,
+                required: false,
+            });
+        }
+        // Outputs
+        const outputs = [];
+        // Determine item type from connected array input
+        let itemType = 'object';
+        if (getConnectedOutput) {
+            const connectedOutput = getConnectedOutput('array');
+            if (connectedOutput?.objectSchema) {
+                // Has objectSchema - it's an object array, use object type
+                itemType = 'object';
+            }
+            else if (connectedOutput?.type && connectedOutput.isArray) {
+                // Connected to an array type - extract the base type
+                const connType = connectedOutput.type;
+                if (!Array.isArray(connType)) {
+                    itemType = connType;
+                }
+            }
+        }
+        // Add item output if exposed
+        if (exposeItem) {
+            outputs.push({ id: 'item', type: itemType, isArray: false, required: true });
+        }
+        // Add index output if exposed
+        if (exposeIndex) {
+            outputs.push({ id: 'index', type: 'number', isArray: false, required: true });
+        }
+        // Add configured property outputs
+        for (const prop of outputProperties) {
+            outputs.push({
+                id: prop.portId,
+                type: prop.type,
+                isArray: prop.isArray,
+                required: true,
+            });
+        }
+        // Add passthrough outputs (same value for all iterations)
+        for (const port of inputPorts) {
+            outputs.push({
+                id: port.id,
+                type: port.type,
+                isArray: port.isArray,
+                required: true,
+            });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/generate-image.d.ts

@@ -0,0 +1,15 @@
+type ImageGenerationTextModel = 'fal-ai/gemini-3-pro-image-preview' | 'fal-ai/nano-banana-pro' | 'fal-ai/nano-banana' | 'fal-ai/gpt-image-1/text-to-image';
+type ImageGenerationEditModel = 'fal-ai/gemini-3-pro-image-preview/edit' | 'fal-ai/nano-banana-pro/edit' | 'fal-ai/nano-banana/edit' | 'fal-ai/gpt-image-1/edit-image';
+type ImageGenerationModel = ImageGenerationTextModel | ImageGenerationEditModel;
+declare function isEditModel(model: ImageGenerationModel): model is ImageGenerationEditModel;
+declare const definition: import("./types").NodeDefinition<"generator", {
+    model: ImageGenerationModel;
+    aspectRatio: string;
+    numImages: number;
+    apiKey: string | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;
+export { isEditModel };
+export type { ImageGenerationTextModel, ImageGenerationEditModel, ImageGenerationModel };

package/dist/automations/nodes/generate-image.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEditModel = isEditModel;
+const types_1 = require("./types");
+function isEditModel(model) {
+    return model.includes('/edit') || model.includes('/edit-image');
+}
+const definition = (0, types_1.defineNode)({
+    nodeId: 'generate-image',
+    label: 'Generate Image',
+    description: 'Generate images with AI',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        model: 'fal-ai/nano-banana',
+        aspectRatio: '1:1',
+        numImages: 1,
+        apiKey: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const model = (config?.model ?? 'fal-ai/nano-banana');
+        const inputs = [
+            { id: 'prompt', type: 'text', isArray: false, required: true },
+        ];
+        if (isEditModel(model)) {
+            inputs.push({ id: 'image', type: 'image', isArray: false, required: true });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'image',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/generate-video.d.ts

@@ -0,0 +1,15 @@
+type VideoGenerationTextToVideoModel = 'fal-ai/veo3.1' | 'fal-ai/veo3' | 'fal-ai/veo3/fast' | 'fal-ai/kling-video/v2.6/pro/text-to-video' | 'fal-ai/kling-video/v2.5/pro/text-to-video' | 'fal-ai/luma-dream-machine/ray-2' | 'fal-ai/luma-dream-machine/ray-2-flash' | 'fal-ai/minimax/hailuo-2.3/pro/text-to-video' | 'wan/v2.6/text-to-video' | 'fal-ai/sora-2/text-to-video';
+type VideoGenerationImageToVideoModel = 'fal-ai/veo3.1/image-to-video' | 'fal-ai/veo3/image-to-video' | 'fal-ai/kling-video/v2.6/pro/image-to-video' | 'fal-ai/kling-video/v2.5/pro/image-to-video' | 'fal-ai/luma-dream-machine/ray-2/image-to-video' | 'fal-ai/luma-dream-machine/ray-2-flash/image-to-video' | 'fal-ai/minimax/hailuo-2.3/pro/image-to-video' | 'wan/v2.6/image-to-video' | 'fal-ai/sora-2/image-to-video/pro';
+type VideoGenerationModel = VideoGenerationTextToVideoModel | VideoGenerationImageToVideoModel;
+declare function isImageToVideoModel(model: VideoGenerationModel): model is VideoGenerationImageToVideoModel;
+declare const definition: import("./types").NodeDefinition<"generator", {
+    model: VideoGenerationModel;
+    aspectRatio: string;
+    duration: number;
+    apiKey: string | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;
+export { isImageToVideoModel };
+export type { VideoGenerationTextToVideoModel, VideoGenerationImageToVideoModel, VideoGenerationModel };

package/dist/automations/nodes/generate-video.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImageToVideoModel = isImageToVideoModel;
+const types_1 = require("./types");
+function isImageToVideoModel(model) {
+    return model.includes('/image-to-video');
+}
+const definition = (0, types_1.defineNode)({
+    nodeId: 'generate-video',
+    label: 'Generate Video',
+    description: 'Generate videos with AI',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        model: 'fal-ai/kling-video/v2.6/pro/text-to-video',
+        aspectRatio: '16:9',
+        duration: 5,
+        apiKey: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const model = (config?.model ?? 'fal-ai/kling-video/v2.6/pro/text-to-video');
+        const inputs = [
+            { id: 'prompt', type: 'text', isArray: false, required: true },
+        ];
+        if (isImageToVideoModel(model)) {
+            inputs.push({ id: 'image', type: 'image', isArray: false, required: true });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'video',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/if.d.ts

@@ -0,0 +1,21 @@
+import type { BasePortType } from '../types';
+declare const IfLogicOperators: readonly ["and", "or", "xor", "nor"];
+type IfLogicOperator = typeof IfLogicOperators[number];
+interface IfBooleanInput {
+    id: string;
+}
+interface IfPassthroughInput {
+    id: string;
+    type: BasePortType;
+    isArray: boolean;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    logicOperator: IfLogicOperator;
+    booleanInputs: IfBooleanInput[];
+    passthroughInputs: IfPassthroughInput[];
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;
+export { IfLogicOperators };
+export type { IfLogicOperator, IfBooleanInput, IfPassthroughInput };

package/dist/automations/nodes/if.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IfLogicOperators = void 0;
+const types_1 = require("./types");
+const IfLogicOperators = ['and', 'or', 'xor', 'nor'];
+exports.IfLogicOperators = IfLogicOperators;
+const definition = (0, types_1.defineNode)({
+    nodeId: 'if',
+    label: 'If',
+    description: 'Conditional branching based on boolean logic',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        logicOperator: 'and',
+        booleanInputs: [{ id: 'condition-1' }],
+        passthroughInputs: [{
+                id: 'value',
+                type: 'image',
+                isArray: false,
+            }],
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const booleanInputs = config?.booleanInputs ?? [];
+        const passthroughInputs = config?.passthroughInputs ?? [];
+        const inputs = [];
+        const outputs = [];
+        // Boolean condition inputs
+        for (const boolInput of booleanInputs) {
+            inputs.push({ id: boolInput.id, type: 'boolean', isArray: false, required: true });
+        }
+        // Passthrough inputs and true/false outputs
+        for (const passthrough of passthroughInputs) {
+            inputs.push({ id: passthrough.id, type: passthrough.type, isArray: passthrough.isArray, required: true });
+            outputs.push({ id: `true-${passthrough.id}`, type: passthrough.type, isArray: passthrough.isArray, required: true });
+            outputs.push({ id: `false-${passthrough.id}`, type: passthrough.type, isArray: passthrough.isArray, required: true });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/image-composer.d.ts

@@ -0,0 +1,46 @@
+import type { ImageEditorElement, DimensionPresetKey, FitMode, DynamicCropConfig } from '../../render/types';
+/**
+ * Image editor node configuration
+ *
+ * This is the complete configuration for an image editor node,
+ * including canvas dimensions, elements, and crop settings.
+ */
+export interface ImageEditorNodeConfig {
+    /** Canvas width in pixels */
+    width: number;
+    /** Canvas height in pixels */
+    height: number;
+    /** Aspect ratio string (e.g., "9:16") */
+    aspectRatio: string;
+    /** Dimension preset key */
+    dimensionPreset: DimensionPresetKey;
+    /** Elements to render */
+    elements: ImageEditorElement[];
+    /** Background type: 'image' for image input, 'color' for solid color */
+    backgroundType?: 'image' | 'color';
+    /** Background color (hex) when backgroundType is 'color' */
+    backgroundColor?: string;
+    /** How the background image fits the canvas */
+    backgroundFit?: FitMode;
+    /** Cached background image URL for consistent preview */
+    previewBackgroundUrl?: string;
+    /** Cached image URLs for image elements (keyed by inputId) */
+    previewImageUrls?: Record<string, string>;
+    /** Cached text values for text elements (keyed by textInputId) */
+    previewTextValues?: Record<string, string>;
+    /** Dynamic cropping configuration */
+    dynamicCrop?: DynamicCropConfig;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    imageEditor: {
+        width: number;
+        height: number;
+        aspectRatio: string;
+        dimensionPreset: string;
+        backgroundType: string;
+        elements: never[];
+    };
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;

package/dist/automations/nodes/image-composer.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'image-composer',
+    label: 'Image Composer',
+    description: 'Create templated images',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        imageEditor: {
+            width: 1080,
+            height: 1920,
+            aspectRatio: '9:16',
+            dimensionPreset: '9:16',
+            backgroundType: 'image',
+            elements: [],
+        },
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const editorConfig = config?.imageEditor;
+        const inputs = [];
+        if (editorConfig) {
+            // Add background input if backgroundType is not 'color'
+            if (editorConfig.backgroundType !== 'color') {
+                inputs.push({
+                    id: 'background',
+                    type: 'image',
+                    isArray: false,
+                    required: true,
+                });
+            }
+            // Add inputs for each element with inputId or textInputId
+            editorConfig.elements.forEach(elem => {
+                if (elem.type === 'image' && elem.inputId) {
+                    inputs.push({
+                        id: elem.inputId,
+                        type: 'image',
+                        isArray: false,
+                        required: true,
+                    });
+                }
+                else if (elem.type === 'text' && elem.textInputId) {
+                    inputs.push({
+                        id: elem.textInputId,
+                        type: 'text',
+                        isArray: false,
+                        required: true,
+                    });
+                }
+            });
+            // Build enum options from element IDs for crop boundary inputs
+            const elementEnumOptions = editorConfig.elements.map(elem => ({
+                label: elem.id,
+                value: elem.id,
+            }));
+            // Add crop boundary inputs as enum type (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);
+                    inputs.push({
+                        id: inputRef,
+                        type: 'enum',
+                        isArray: false,
+                        required: false,
+                        enumOptions: elementEnumOptions,
+                    });
+                }
+            });
+        }
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'output',
+                    type: 'image',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+    resolvePreview: (config) => {
+        const editorConfig = config?.imageEditor;
+        if (!editorConfig)
+            return null;
+        const sources = {};
+        const textContent = {};
+        // Add background URL if available
+        if (editorConfig.previewBackgroundUrl) {
+            sources['background'] = editorConfig.previewBackgroundUrl;
+        }
+        // Resolve image elements: inputId -> element.id
+        // Resolve text elements: textInputId -> element.id
+        for (const elem of editorConfig.elements) {
+            if (elem.type === 'image' && elem.inputId) {
+                const url = editorConfig.previewImageUrls?.[elem.inputId];
+                if (url) {
+                    sources[elem.id] = url;
+                }
+            }
+            else if (elem.type === 'text' && elem.textInputId) {
+                const text = editorConfig.previewTextValues?.[elem.textInputId];
+                if (text) {
+                    textContent[elem.id] = text;
+                }
+            }
+        }
+        return {
+            renderConfig: {
+                elements: editorConfig.elements,
+                width: editorConfig.width,
+                height: editorConfig.height,
+                backgroundType: editorConfig.backgroundType,
+                backgroundColor: editorConfig.backgroundColor,
+                backgroundFit: editorConfig.backgroundFit,
+                dynamicCrop: editorConfig.dynamicCrop,
+            },
+            sources,
+            textContent,
+        };
+    },
+});
+exports.default = definition;