ugcinc 4.1.21 → 4.1.23

package/dist/nodes/auto-post.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'auto-post',
-    label: 'Auto Post',
-    description: 'Publish a video or slideshow',
-    type: 'terminal',
-    category: 'Output',
-    outputModes: null,
-    selectionModes: null,
-    defaults: {
-        mode: 'video',
-        inputType: 'static',
-        inputs: [],
-        socialAudioIsVariable: false,
-        schedulingMode: 'scheduled',
-        minDistanceHours: 4,
-        maxPostsPerDay: 3,
-        randomWindowStart: '09:00',
-        randomWindowEnd: '21:00',
-        timezone: 'America/New_York',
-        requireApproval: false,
-        outputMode: null,
-        selectionMode: null,
-    },
-    computePorts: ({ config }) => {
-        const mode = config?.mode ?? 'video';
-        const inputs = [];
-        if (mode === 'video') {
-            inputs.push({ id: 'video', type: 'video', isArray: false, required: true });
-        }
-        else {
-            const inputType = config?.inputType ?? 'static';
-            if (inputType === 'variable') {
-                inputs.push({ id: 'images', type: 'object', isArray: false, required: true });
-            }
-            else {
-                const imageInputs = config?.inputs ?? [{ id: 'image1' }, { id: 'image2' }, { id: 'image3' }];
-                for (const input of imageInputs) {
-                    inputs.push({ id: input.id, type: 'image', isArray: false, required: true });
-                }
-            }
-        }
-        // Static inputs for both modes
-        inputs.push({ id: 'account', type: 'account', isArray: false, required: true }, { id: 'caption', type: 'text', isArray: false, required: false });
-        // Social audio variable input
-        if (config?.socialAudioIsVariable) {
-            inputs.push({ id: 'social-audio', type: 'audio', isArray: false, required: false });
-        }
-        return { inputs, outputs: [] };
-    },
-});
-exports.default = definition;

package/dist/nodes/branch.d.ts

@@ -1,12 +0,0 @@
-import type { PassthroughInput } from './types';
-declare const definition: import("./types").NodeDefinition<"generator", {
-    branches: {
-        key: string;
-    }[];
-    passthroughInputs: PassthroughInput[];
-    defaultBranchKey: string;
-    outputMode: "per-input";
-    selectionMode: null;
-}>;
-export default definition;
-export type BranchConfig = typeof definition.defaults;

package/dist/nodes/branch.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'branch',
-    label: 'Branch',
-    description: 'Route inputs based on a key match',
-    type: 'generator',
-    category: 'Control Flow',
-    outputModes: ['per-input', 'single'],
-    selectionModes: null,
-    defaults: {
-        branches: [
-            { key: 'option-a' },
-            { key: 'option-b' },
-        ],
-        passthroughInputs: [{ id: 'input', type: 'image', isArray: false }],
-        defaultBranchKey: 'option-a',
-        outputMode: 'per-input',
-        selectionMode: null,
-    },
-    computePorts: ({ config }) => {
-        const branches = config?.branches ?? [];
-        const passthroughInputs = config?.passthroughInputs ?? [];
-        const inputs = [];
-        const outputs = [];
-        // Always add key input for branch selection
-        inputs.push({ id: 'key', type: 'text', isArray: false, required: true });
-        // Add input ports for each branch × passthrough where isVariable is true
-        for (const passthrough of passthroughInputs) {
-            const pType = passthrough.type;
-            const pIsArray = passthrough.isArray ?? false;
-            for (const branch of branches) {
-                const branchValue = passthrough.branchValues?.[branch.key];
-                if (branchValue?.inputType === 'variable') {
-                    inputs.push({
-                        id: `${branch.key}-${passthrough.id}`,
-                        type: pType,
-                        isArray: pIsArray,
-                        required: true,
-                    });
-                }
-            }
-            // One output per passthrough
-            outputs.push({ id: passthrough.id, type: pType, isArray: pIsArray, required: true });
-        }
-        return { inputs, outputs };
-    },
-});
-exports.default = definition;

package/dist/nodes/collect.d.ts

@@ -1,6 +0,0 @@
-declare const definition: import("./types").NodeDefinition<"generator", {
-    outputMode: "single";
-    selectionMode: null;
-}>;
-export default definition;
-export type CollectConfig = typeof definition.defaults;

package/dist/nodes/collect.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'collect',
-    label: 'Collect',
-    description: 'Collect outputs from a for-each loop into an array',
-    type: 'generator',
-    category: 'Control Flow',
-    outputModes: ['per-input', 'single'],
-    selectionModes: null,
-    defaults: {
-        outputMode: 'single', // Collect produces a single output after all loop iterations complete
-        selectionMode: null,
-    },
-    computePorts: ({ getConnectedOutput }) => {
-        // Input: accepts any non-array type (union)
-        const inputTypes = ['image', 'video', 'audio', 'text', 'object', 'boolean', 'number'];
-        // Default output: union of all types (will be array)
-        const defaultOutputTypes = ['image', 'video', 'audio', 'text', 'object'];
-        // Determine output type from connected input (inverse of for-each pattern)
-        let outputType = defaultOutputTypes;
-        let outputIsArray = true;
-        if (getConnectedOutput) {
-            const connectedOutput = getConnectedOutput('value');
-            if (connectedOutput?.type) {
-                const connType = connectedOutput.type;
-                // Handle single type (not a union)
-                if (!Array.isArray(connType) && !connectedOutput.isArray) {
-                    // If connected to a non-array type, output is an array of that type
-                    outputType = connType;
-                    outputIsArray = true;
-                }
-                // If connected to a union type, can't narrow - keep default union
-            }
-        }
-        const inputs = [
-            {
-                id: 'value',
-                type: inputTypes,
-                isArray: false,
-                required: true,
-            },
-        ];
-        const outputs = [
-            {
-                id: 'array',
-                type: outputType,
-                isArray: outputIsArray,
-                required: true,
-            },
-        ];
-        return { inputs, outputs };
-    },
-});
-exports.default = definition;

package/dist/nodes/compose-workflow.d.ts

@@ -1,21 +0,0 @@
-import type { ResolvedPorts, EnumOption } from '../types';
-import { type ObjectSchemaField } from './types';
-declare const definition: import("./types").NodeDefinition<"generator", {
-    workflowTemplateId: string | undefined;
-    workflowVariableNodes: Array<{
-        id: string;
-        name?: string;
-        variableType?: "image" | "video" | "audio" | "text" | "enum";
-        enumOptions?: EnumOption[];
-    }>;
-    workflowOutputSchema: Record<string, {
-        type: string;
-        isArray?: boolean;
-        objectSchema?: ObjectSchemaField[];
-    }>;
-    resolvedPorts: ResolvedPorts | undefined;
-    outputMode: "per-input";
-    selectionMode: null;
-}>;
-export default definition;
-export type ComposeWorkflowConfig = typeof definition.defaults;

package/dist/nodes/compose-workflow.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'compose-workflow',
-    label: 'Compose Workflow',
-    description: 'Embed other workflows',
-    type: 'generator',
-    category: 'Generation',
-    outputModes: ['per-input', 'single'],
-    selectionModes: null,
-    defaults: {
-        workflowTemplateId: undefined,
-        workflowVariableNodes: [],
-        workflowOutputSchema: {},
-        resolvedPorts: undefined,
-        outputMode: 'per-input',
-        selectionMode: null,
-    },
-    computePorts: ({ config }) => {
-        const variableNodes = config?.workflowVariableNodes ?? [];
-        const outputSchema = config?.workflowOutputSchema ?? {};
-        // Inputs from workflow variable nodes
-        const inputs = variableNodes.map(v => ({
-            id: v.id,
-            type: (v.variableType ?? 'text'),
-            isArray: false,
-            required: true,
-            ...(v.variableType === 'enum' && v.enumOptions ? { enumOptions: v.enumOptions } : {}),
-        }));
-        // Outputs from workflow output schema
-        const outputs = Object.entries(outputSchema).map(([id, schema]) => ({
-            id,
-            type: schema.type,
-            isArray: schema.isArray ?? false,
-            required: true,
-            ...(schema.objectSchema && { objectSchema: schema.objectSchema }),
-        }));
-        return { inputs, outputs };
-    },
-});
-exports.default = definition;

package/dist/nodes/create-dm.d.ts

@@ -1,40 +0,0 @@
-import type { InputType } from './types';
-type DmPlatform = 'imessage' | 'instagram';
-interface DmMessage {
-    sender: 'user' | 'recipient';
-    text: string;
-    hasImage?: boolean;
-}
-declare const definition: import("./types").NodeDefinition<"generator", {
-    platform: DmPlatform;
-    platformIsVariable: boolean;
-    lightMode: boolean;
-    lightModeIsVariable: boolean;
-    username: string;
-    usernameIsVariable: boolean;
-    time: string;
-    timeIsVariable: boolean;
-    profilePicUrl: string;
-    profilePicIsVariable: boolean;
-    messagesInputType: InputType;
-    messages: DmMessage[];
-    imageAttachmentUrl: string | undefined;
-    imageAttachmentIsVariable: boolean;
-    imessage: {
-        senderBubbleColor: string | undefined;
-        showReadReceipt: boolean;
-        readReceiptText: string;
-        readReceiptTimeIsVariable: boolean;
-        unreadBadgeText: string;
-        unreadBadgeIsVariable: boolean;
-        messageHeaderTimestampText: string;
-        messageHeaderTimeIsVariable: boolean;
-    };
-    instagram: {
-        userHasStory: boolean;
-    };
-    outputMode: "per-input";
-    selectionMode: null;
-}>;
-export default definition;
-export type CreateDmConfig = typeof definition.defaults;

package/dist/nodes/create-dm.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'create-dm',
-    label: 'Create DM',
-    description: 'Create fake DM screenshots for iMessage or Instagram',
-    type: 'generator',
-    category: 'Generation',
-    outputModes: ['per-input', 'single'],
-    selectionModes: null,
-    defaults: {
-        platform: 'instagram',
-        platformIsVariable: false,
-        lightMode: true,
-        lightModeIsVariable: false,
-        username: '',
-        usernameIsVariable: false,
-        time: '9:41',
-        timeIsVariable: false,
-        profilePicUrl: 'https://ugcinc.co/logo.png',
-        profilePicIsVariable: false,
-        messagesInputType: 'static',
-        messages: [
-            { sender: 'user', text: 'Wow, this dm automation is realistic right 🤯' },
-            { sender: 'recipient', text: "I know, it's like we're really in imessage" },
-            { sender: 'recipient', text: 'Just be thankful we\'re not on android 😭😭😭' },
-        ],
-        imageAttachmentUrl: undefined,
-        imageAttachmentIsVariable: false,
-        imessage: {
-            senderBubbleColor: undefined,
-            showReadReceipt: false,
-            readReceiptText: 'Read',
-            readReceiptTimeIsVariable: false,
-            unreadBadgeText: '67',
-            unreadBadgeIsVariable: false,
-            messageHeaderTimestampText: '',
-            messageHeaderTimeIsVariable: false,
-        },
-        instagram: {
-            userHasStory: false,
-        },
-        outputMode: 'per-input',
-        selectionMode: null,
-    },
-    computePorts: ({ config }) => {
-        const inputs = [];
-        if (config?.platformIsVariable) {
-            inputs.push({ id: 'platform', type: 'text', isArray: false, required: true });
-        }
-        if (config?.lightModeIsVariable) {
-            inputs.push({ id: 'light-mode', type: 'boolean', isArray: false, required: false });
-        }
-        if (config?.usernameIsVariable) {
-            inputs.push({ id: 'username', type: 'text', isArray: false, required: true });
-        }
-        if (config?.timeIsVariable) {
-            inputs.push({ id: 'time', type: 'text', isArray: false, required: false });
-        }
-        if (config?.profilePicIsVariable) {
-            inputs.push({ id: 'profile-pic', type: 'image', isArray: false, required: false });
-        }
-        if (config?.messagesInputType === 'variable') {
-            inputs.push({ id: 'messages', type: 'object', isArray: true, required: true });
-        }
-        if (config?.imageAttachmentIsVariable) {
-            inputs.push({ id: 'image-attachment', type: 'image', isArray: false, required: false });
-        }
-        // iMessage-specific
-        if (config?.platform === 'imessage') {
-            if (config.imessage?.showReadReceipt && config.imessage?.readReceiptTimeIsVariable) {
-                inputs.push({ id: 'read-receipt-time', type: 'text', isArray: false, required: false });
-            }
-            if (config.imessage?.unreadBadgeIsVariable) {
-                inputs.push({ id: 'unread-badge', type: 'text', isArray: false, required: false });
-            }
-            if (config.imessage?.messageHeaderTimeIsVariable) {
-                inputs.push({ id: 'message-header-time', type: 'text', isArray: false, required: false });
-            }
-        }
-        return {
-            inputs,
-            outputs: [{ id: 'output', type: 'image', isArray: false, required: true }],
-        };
-    },
-});
-exports.default = definition;

package/dist/nodes/custom-model.d.ts

@@ -1,19 +0,0 @@
-type CustomModelOutputType = 'image' | 'video' | 'audio';
-interface CustomModelInputParam {
-    name: string;
-    type: string;
-    required: boolean;
-    description?: string;
-    default?: unknown;
-}
-declare const definition: import("./types").NodeDefinition<"generator", {
-    modelId: string;
-    modelName: string;
-    outputType: CustomModelOutputType;
-    inputParams: CustomModelInputParam[];
-    apiKey: string | undefined;
-    outputMode: "per-input";
-    selectionMode: null;
-}>;
-export default definition;
-export type CustomModelConfig = typeof definition.defaults;

package/dist/nodes/custom-model.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'custom-model',
-    label: 'Custom Model',
-    description: 'Call any fal.ai model',
-    type: 'generator',
-    category: 'AI Generation',
-    outputModes: ['per-input', 'single'],
-    selectionModes: null,
-    defaults: {
-        modelId: '',
-        modelName: '',
-        outputType: 'image',
-        inputParams: [],
-        apiKey: undefined,
-        outputMode: 'per-input',
-        selectionMode: null,
-    },
-    computePorts: ({ config }) => {
-        const inputParams = config?.inputParams ?? [];
-        const outputType = config?.outputType ?? 'image';
-        // Generate input ports from inputParams
-        // Only params with name 'prompt' or type image/video/audio become input ports
-        const inputs = inputParams
-            .filter(param => param.name === 'prompt' ||
-            param.type === 'image' ||
-            param.type === 'video' ||
-            param.type === 'audio')
-            .map(param => ({
-            id: param.name,
-            type: (param.type === 'image' || param.type === 'video' || param.type === 'audio')
-                ? param.type
-                : 'text',
-            isArray: false,
-            required: param.required,
-        }));
-        return {
-            inputs,
-            outputs: [
-                {
-                    id: 'output',
-                    type: outputType,
-                    isArray: false,
-                    required: true,
-                },
-            ],
-        };
-    },
-});
-exports.default = definition;

package/dist/nodes/deduplicate.d.ts

@@ -1,8 +0,0 @@
-import type { DeduplicationLevel } from '../render/types';
-declare const definition: import("./types").NodeDefinition<"generator", {
-    deduplication: DeduplicationLevel;
-    outputMode: "per-input";
-    selectionMode: null;
-}>;
-export default definition;
-export type DeduplicateConfig = typeof definition.defaults;

package/dist/nodes/deduplicate.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'deduplicate',
-    label: 'Mass Repost',
-    description: 'Make videos unique for safe reposting',
-    type: 'generator',
-    category: 'Generation',
-    outputModes: ['per-input', 'single'],
-    selectionModes: null,
-    defaults: {
-        deduplication: 'level3',
-        outputMode: 'per-input',
-        selectionMode: null,
-    },
-    computePorts: () => ({
-        inputs: [
-            {
-                id: 'video',
-                type: 'video',
-                isArray: false,
-                required: true,
-            },
-        ],
-        outputs: [
-            {
-                id: 'output',
-                type: 'video',
-                isArray: false,
-                required: true,
-            },
-        ],
-    }),
-});
-exports.default = definition;

package/dist/nodes/destructure.d.ts

@@ -1,25 +0,0 @@
-type IndexExpression = {
-    type: 'single';
-    index: number;
-} | {
-    type: 'range';
-    start: number;
-    end: number;
-} | {
-    type: 'list';
-    indexes: number[];
-};
-interface DestructureSelection {
-    portId: string;
-    indexExpr: IndexExpression;
-    isVariable?: boolean;
-    propertyPath?: string;
-}
-declare const definition: import("./types").NodeDefinition<"generator", {
-    selections: DestructureSelection[];
-    outputMode: "per-input";
-    selectionMode: null;
-}>;
-export default definition;
-export type { DestructureSelection, IndexExpression };
-export type DestructureConfig = typeof definition.defaults;

package/dist/nodes/destructure.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'destructure',
-    label: 'Destructure',
-    description: 'Extract specific elements from an array by index or range',
-    type: 'generator',
-    category: 'Control Flow',
-    outputModes: ['per-input', 'single'],
-    selectionModes: null,
-    defaults: {
-        selections: [],
-        outputMode: 'per-input',
-        selectionMode: null,
-    },
-    computePorts: ({ config, getConnectedOutput }) => {
-        const selections = config?.selections ?? [];
-        // Input accepts any array type
-        const inputTypes = ['image', 'video', 'audio', 'text', 'object'];
-        const inputs = [
-            {
-                id: 'array',
-                type: inputTypes,
-                isArray: true,
-                required: true,
-            },
-        ];
-        const outputs = [];
-        // Determine base type from connected input
-        let baseType = 'object';
-        if (getConnectedOutput) {
-            const connectedOutput = getConnectedOutput('array');
-            if (connectedOutput?.type && connectedOutput.isArray) {
-                const connType = connectedOutput.type;
-                if (!Array.isArray(connType)) {
-                    baseType = connType;
-                }
-            }
-        }
-        for (const selection of selections) {
-            // If variable, add input port for index expression
-            if (selection.isVariable) {
-                inputs.push({
-                    id: `idx-${selection.portId}`,
-                    type: 'text',
-                    isArray: false,
-                    required: true,
-                });
-            }
-            // Output type depends on index expression:
-            // - 'single' -> single item (isArray: false)
-            // - 'range' or 'list' -> array of items (isArray: true)
-            const outputIsArray = selection.indexExpr.type !== 'single';
-            outputs.push({
-                id: selection.portId,
-                type: baseType,
-                isArray: outputIsArray,
-                required: true,
-            });
-        }
-        return { inputs, outputs };
-    },
-});
-exports.default = definition;

package/dist/nodes/for-each.d.ts

@@ -1,23 +0,0 @@
-import type { BasePortType } from '../types';
-interface ForEachOutputProperty {
-    portId: string;
-    propertyPath: string;
-    type: BasePortType;
-    isArray: boolean;
-}
-interface ForEachInputPort {
-    id: string;
-    type: BasePortType;
-    isArray: boolean;
-}
-declare const definition: import("./types").NodeDefinition<"generator", {
-    outputProperties: ForEachOutputProperty[];
-    inputPorts: ForEachInputPort[];
-    exposeItem: boolean;
-    exposeIndex: boolean;
-    outputMode: "per-input";
-    selectionMode: null;
-}>;
-export default definition;
-export type { ForEachOutputProperty, ForEachInputPort };
-export type ForEachConfig = typeof definition.defaults;