ugcinc 4.0.2 → 4.1.1

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

@@ -0,0 +1,16 @@
+import type { BasePortType } from '../types';
+import { type ObjectSchemaField } from './types';
+export interface OutputInput {
+    id: string;
+    type: BasePortType;
+    tag?: string;
+    isArray?: boolean;
+    objectSchema?: ObjectSchemaField[];
+}
+declare const definition: import("./types").NodeDefinition<"terminal", {
+    inputs: OutputInput[];
+    mainPreviewInputId: string | undefined;
+    outputMode: null;
+    selectionMode: null;
+}, false>;
+export default definition;

package/dist/automations/nodes/output.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'passthrough',
+    label: 'Pass-Through',
+    description: 'Pass data to parent workflow',
+    type: 'terminal',
+    category: 'Output',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        inputs: [{ id: 'result', type: 'image' }],
+        mainPreviewInputId: undefined,
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const configInputs = config?.inputs ?? [];
+        const inputs = configInputs.map(input => ({
+            id: input.id,
+            type: input.type,
+            isArray: input.isArray ?? false,
+            required: false,
+        }));
+        return {
+            inputs,
+            outputs: [],
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/random-route.d.ts

@@ -0,0 +1,24 @@
+import { type InputType } from './types';
+export interface RandomRouteBranch {
+    id: string;
+    probability: number;
+}
+export interface RandomRouteObjectField {
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+}
+export interface RandomRoutePassthroughInput {
+    id: string;
+    type: 'image' | 'video' | 'audio' | 'text' | 'number' | 'boolean' | 'account' | 'object';
+    isArray?: boolean;
+    inputType?: InputType;
+    defaultValue?: unknown;
+    objectSchema?: RandomRouteObjectField[];
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    branches: RandomRouteBranch[];
+    passthroughInputs: RandomRoutePassthroughInput[];
+    outputMode: "single";
+    selectionMode: null;
+}, false>;
+export default definition;

package/dist/automations/nodes/random-route.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'random-route',
+    label: 'Random Branch',
+    description: 'Route inputs to a randomly selected branch',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        branches: [
+            { id: 'branch-1', probability: 50 },
+            { id: 'branch-2', probability: 50 },
+        ],
+        passthroughInputs: [
+            { id: 'input', type: 'image', isArray: false, inputType: 'static' },
+        ],
+        outputMode: 'single',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const branches = config?.branches ?? [];
+        const passthroughInputs = config?.passthroughInputs ?? [];
+        const inputs = [];
+        const outputs = [];
+        // Input ports: only passthroughs where inputType is 'variable'
+        for (const passthrough of passthroughInputs) {
+            if (passthrough.inputType === 'variable') {
+                inputs.push({
+                    id: passthrough.id,
+                    type: passthrough.type,
+                    isArray: passthrough.isArray ?? false,
+                    required: true,
+                });
+            }
+        }
+        // Output ports: {branch.id}-{passthrough.id} for each combination
+        for (const branch of branches) {
+            for (const passthrough of passthroughInputs) {
+                outputs.push({
+                    id: `${branch.id}-${passthrough.id}`,
+                    type: passthrough.type,
+                    isArray: passthrough.isArray ?? false,
+                    required: true,
+                });
+            }
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,16 @@
+import { type InputType } from './types';
+export interface RandomInputPort {
+    id: string;
+    probability: number;
+    inputType: InputType;
+    defaultValue?: unknown;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    mode: "array" | "multi-input";
+    valueType: string;
+    exposeIndex: boolean;
+    inputPorts: RandomInputPort[];
+    outputMode: "single";
+    selectionMode: null;
+}, false>;
+export default definition;

package/dist/automations/nodes/random.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'random',
+    label: 'Random Select',
+    description: 'Randomly select from an array or weighted inputs',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        mode: 'array',
+        valueType: 'object',
+        exposeIndex: false,
+        inputPorts: [],
+        outputMode: 'single',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const mode = config?.mode ?? 'array';
+        const valueType = (config?.valueType ?? 'object');
+        const exposeIndex = config?.exposeIndex ?? false;
+        const inputPorts = config?.inputPorts ?? [];
+        const inputs = [];
+        const outputs = [];
+        if (mode === 'array') {
+            inputs.push({ id: 'array', type: 'object', isArray: false, required: true });
+        }
+        else {
+            // Multi-input mode: only add ports where inputType is 'variable'
+            for (const port of inputPorts) {
+                if (port.inputType === 'variable') {
+                    inputs.push({
+                        id: port.id,
+                        type: valueType,
+                        isArray: false,
+                        required: true,
+                    });
+                }
+            }
+        }
+        outputs.push({ id: 'output', type: valueType, isArray: false, required: true });
+        if (mode === 'array' && exposeIndex) {
+            outputs.push({ id: 'index', type: 'number', isArray: false, required: true });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,29 @@
+import { type TriggerCollectionConfig, type MediaItemType } from './types';
+export type DayOfWeek = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday';
+export interface RecurrenceMediaOutput {
+    id: string;
+    type: MediaItemType;
+    selectionMode: 'specific' | 'by-tag';
+    selectedMediaIds?: string[];
+    mediaTag?: string;
+}
+export interface RecurrenceMediaConfig {
+    enabled: boolean;
+    outputs: RecurrenceMediaOutput[];
+}
+declare const definition: import("./types").NodeDefinition<"trigger", {
+    frequencyType: "per-day" | "periodic";
+    runsPerDay: number;
+    periodDays: number;
+    daysOfWeek: DayOfWeek[];
+    timingType: "specific" | "random-window";
+    specificTimes: string[];
+    randomWindowStart: string;
+    randomWindowEnd: string;
+    timezone: string;
+    collectionInput: TriggerCollectionConfig | undefined;
+    mediaInput: RecurrenceMediaConfig | undefined;
+    outputMode: null;
+    selectionMode: null;
+}, false>;
+export default definition;

package/dist/automations/nodes/recurrence.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'recurrence',
+    label: 'Recurring',
+    description: 'Run continuously',
+    type: 'trigger',
+    category: 'Triggers',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        frequencyType: 'per-day',
+        runsPerDay: 1,
+        periodDays: 7,
+        daysOfWeek: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday'],
+        timingType: 'random-window',
+        specificTimes: ['09:00'],
+        randomWindowStart: '09:00',
+        randomWindowEnd: '17:00',
+        timezone: 'America/New_York',
+        collectionInput: undefined,
+        mediaInput: undefined,
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const collectionInputEnabled = config?.collectionInput?.enabled;
+        const mediaOutputs = config?.mediaInput?.outputs ?? [];
+        const outputs = [];
+        // Add account output if collection input is enabled
+        if (collectionInputEnabled) {
+            outputs.push({ id: 'account', type: 'account', isArray: false, required: true });
+        }
+        // Add media outputs
+        for (const output of mediaOutputs) {
+            outputs.push({
+                id: output.id,
+                type: output.type,
+                isArray: false,
+                required: true,
+            });
+        }
+        return {
+            inputs: [],
+            outputs,
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/save-to-media.d.ts

@@ -0,0 +1,15 @@
+type SaveToMediaType = 'image' | 'video' | 'audio' | 'text';
+export interface SaveToMediaInput {
+    id: string;
+    type: SaveToMediaType;
+    tag?: string;
+}
+declare const definition: import("./types").NodeDefinition<"terminal", {
+    inputs: SaveToMediaInput[];
+    globalTag: string | undefined;
+    includeDateTag: boolean;
+    makeUnique: boolean;
+    outputMode: null;
+    selectionMode: null;
+}, false>;
+export default definition;

package/dist/automations/nodes/save-to-media.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'save-to-media',
+    label: 'Save To Media',
+    description: 'Save outputs to media library',
+    type: 'terminal',
+    category: 'Output',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        inputs: [{ id: 'input', type: 'image' }],
+        globalTag: undefined,
+        includeDateTag: false,
+        makeUnique: false,
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const configInputs = config?.inputs ?? [];
+        const inputs = configInputs.map(input => ({
+            id: input.id,
+            type: input.type,
+            isArray: false,
+            required: true,
+        }));
+        return { inputs, outputs: [] };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/screenshot-animation.d.ts

@@ -0,0 +1,6 @@
+declare const definition: import("./types").NodeDefinition<"generator", {
+    holdDurationMs: number;
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;

package/dist/automations/nodes/screenshot-animation.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'screenshot-animation',
+    label: 'Animate Screenshot',
+    description: 'Create an iPhone screenshot animation from an image',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        holdDurationMs: 500,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'image',
+                type: 'image',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'output',
+                type: 'video',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

package/dist/automations/nodes/social-audio.d.ts

@@ -0,0 +1,7 @@
+declare const definition: import("./types").NodeDefinition<"source", {
+    urls: string[];
+    selectedMediaIds: string[];
+    selectionMode: "random";
+    outputMode: "per-input";
+}, false>;
+export default definition;

package/dist/automations/nodes/social-audio.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'social-audio',
+    label: 'Social Audio',
+    description: 'Select trending audio for posts',
+    type: 'source',
+    category: 'Sources',
+    outputModes: ['per-input', 'single'],
+    selectionModes: ['random', 'sequential'],
+    defaults: {
+        urls: [],
+        selectedMediaIds: [],
+        selectionMode: 'random',
+        outputMode: 'per-input',
+    },
+    computePorts: () => ({
+        inputs: [],
+        outputs: [
+            {
+                id: 'social-audio',
+                type: 'social_audio',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

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

@@ -0,0 +1,6 @@
+declare const definition: import("./types").NodeDefinition<"source", {
+    textOptions: string[];
+    selectionMode: "random";
+    outputMode: "per-input";
+}, false>;
+export default definition;

package/dist/automations/nodes/text.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const internal_utils_1 = require("../../internal-utils");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'text',
+    label: 'Text',
+    description: 'Use text collections',
+    type: 'source',
+    category: 'Sources',
+    outputModes: ['per-input', 'single'],
+    selectionModes: ['random', 'sequential'],
+    defaults: {
+        textOptions: [],
+        selectionMode: 'random',
+        outputMode: 'per-input',
+    },
+    computePorts: ({ config }) => {
+        const textOptions = (config?.textOptions ?? []);
+        const variables = (0, internal_utils_1.extractTemplateVariables)(textOptions);
+        // Generate inputs from template variables
+        const inputs = variables.map(variable => ({
+            id: variable,
+            type: 'text',
+            isArray: false,
+            required: false,
+        }));
+        return {
+            inputs,
+            outputs: [
+                {
+                    id: 'text',
+                    type: 'text',
+                    isArray: false,
+                    required: true,
+                },
+            ],
+        };
+    },
+});
+exports.default = definition;

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

@@ -0,0 +1,5 @@
+declare const definition: import("./types").NodeDefinition<"generator", {
+    outputMode: "per-input";
+    selectionMode: null;
+}, false>;
+export default definition;

package/dist/automations/nodes/transcript.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'transcript',
+    label: 'Transcribe',
+    description: 'Transcribe video or audio with timestamps',
+    type: 'generator',
+    category: 'Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'media',
+                type: ['video', 'audio'],
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'text',
+                type: 'text',
+                isArray: false,
+                required: true,
+            },
+            {
+                id: 'segments',
+                type: 'object',
+                isArray: false,
+                required: true,
+                objectSchema: [
+                    { name: 'text', type: 'string' },
+                    { name: 'start', type: 'number' },
+                    { name: 'end', type: 'number' },
+                ],
+            },
+        ],
+    }),
+});
+exports.default = definition;