ugcinc 4.1.0 → 4.1.1

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

@@ -1,96 +1,35 @@
+import { type InputType } from './types';
 type DmPlatform = 'imessage' | 'instagram';
-/**
- * Message in a Create DM conversation
- */
 export interface CreateDmMessage {
-    /** Who sent this message */
     sender: 'user' | 'recipient';
-    /** Message text content */
     text: string;
-    /** Whether this message has an associated image (story reply for IG, sender image for iMessage) */
     hasImage?: boolean;
 }
-/**
- * Create DM node configuration - renders fake DM conversations for iMessage or Instagram
- */
-export interface CreateDmNodeConfig {
-    /** Platform to render */
-    platform: 'imessage' | 'instagram';
-    /** Whether platform comes from input port */
-    platformIsVariable?: boolean;
-    /** Light or dark mode */
-    lightMode: boolean;
-    /** Whether light mode comes from input port */
-    lightModeIsVariable?: boolean;
-    /** Username displayed in header */
-    username: string;
-    /** Whether username comes from input port */
-    usernameIsVariable?: boolean;
-    /** Status bar time */
-    time: string;
-    /** Whether status bar time comes from input port */
-    timeIsVariable?: boolean;
-    /** Profile picture URL (fallback if profilePic input not connected) */
-    profilePicUrl?: string;
-    /** Whether profile pic comes from input port */
-    profilePicIsVariable?: boolean;
-    /** Whether messages come from input port */
-    messagesIsVariable?: boolean;
-    /** Static messages (used when messagesIsVariable is false) */
-    messages?: CreateDmMessage[];
-    /** Image attachment URL (story reply for IG, sender image for iMessage) */
-    imageAttachmentUrl?: string;
-    /** Whether image attachment comes from input port */
-    imageAttachmentIsVariable?: boolean;
-    /** iMessage-specific settings */
-    imessage?: {
-        senderBubbleColor?: string;
-        showReadReceipt: boolean;
-        readReceiptText: string;
-        /** Whether read receipt time comes from input port */
-        readReceiptTimeIsVariable?: boolean;
-        unreadBadgeText: string;
-        /** Whether unread badge comes from input port */
-        unreadBadgeIsVariable?: boolean;
-        messageHeaderTimestampText: string;
-        /** Whether message header time comes from input port */
-        messageHeaderTimeIsVariable?: boolean;
-    };
-    /** Instagram-specific settings */
-    instagram?: {
-        userHasStory: boolean;
-    };
-}
 declare const definition: import("./types").NodeDefinition<"generator", {
     platform: DmPlatform;
-    platformIsVariable: boolean;
+    platformInputType: InputType;
     lightMode: boolean;
-    lightModeIsVariable: boolean;
+    lightModeInputType: InputType;
     username: string;
-    usernameIsVariable: boolean;
+    usernameInputType: InputType;
     time: string;
-    timeIsVariable: boolean;
+    timeInputType: InputType;
     profilePicUrl: string;
-    profilePicIsVariable: boolean;
-    messagesIsVariable: boolean;
+    profilePicInputType: InputType;
     messages: CreateDmMessage[];
+    messagesInputType: InputType;
     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;
-    };
+    imageAttachmentInputType: InputType;
+    imessageSenderBubbleColor: string | undefined;
+    imessageShowReadReceipt: boolean;
+    imessageReadReceiptText: string;
+    imessageReadReceiptTimeInputType: InputType;
+    imessageUnreadBadgeText: string;
+    imessageUnreadBadgeInputType: InputType;
+    imessageMessageHeaderTimestampText: string;
+    imessageMessageHeaderTimeInputType: InputType;
+    instagramUserHasStory: boolean;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type CreateDmConfig = typeof definition.defaults;

package/dist/automations/nodes/create-dm.js

@@ -11,71 +11,69 @@ const definition = (0, types_1.defineNode)({
     selectionModes: null,
     defaults: {
         platform: 'instagram',
-        platformIsVariable: false,
+        platformInputType: 'static',
         lightMode: true,
-        lightModeIsVariable: false,
+        lightModeInputType: 'static',
         username: '',
-        usernameIsVariable: false,
+        usernameInputType: 'static',
         time: '9:41',
-        timeIsVariable: false,
+        timeInputType: 'static',
         profilePicUrl: 'https://ugcinc.co/logo.png',
-        profilePicIsVariable: false,
-        messagesIsVariable: false,
+        profilePicInputType: '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 😭😭😭' },
         ],
+        messagesInputType: 'static',
         imageAttachmentUrl: undefined,
-        imageAttachmentIsVariable: false,
-        imessage: {
-            senderBubbleColor: undefined,
-            showReadReceipt: false,
-            readReceiptText: 'Read',
-            readReceiptTimeIsVariable: false,
-            unreadBadgeText: '67',
-            unreadBadgeIsVariable: false,
-            messageHeaderTimestampText: '',
-            messageHeaderTimeIsVariable: false,
-        },
-        instagram: {
-            userHasStory: false,
-        },
+        imageAttachmentInputType: 'static',
+        // iMessage-specific
+        imessageSenderBubbleColor: undefined,
+        imessageShowReadReceipt: false,
+        imessageReadReceiptText: 'Read',
+        imessageReadReceiptTimeInputType: 'static',
+        imessageUnreadBadgeText: '67',
+        imessageUnreadBadgeInputType: 'static',
+        imessageMessageHeaderTimestampText: '',
+        imessageMessageHeaderTimeInputType: 'static',
+        // Instagram-specific
+        instagramUserHasStory: false,
         outputMode: 'per-input',
         selectionMode: null,
     },
     computePorts: ({ config }) => {
         const inputs = [];
-        if (config?.platformIsVariable) {
+        if (config?.platformInputType === 'variable') {
             inputs.push({ id: 'platform', type: 'text', isArray: false, required: true });
         }
-        if (config?.lightModeIsVariable) {
+        if (config?.lightModeInputType === 'variable') {
             inputs.push({ id: 'light-mode', type: 'boolean', isArray: false, required: false });
         }
-        if (config?.usernameIsVariable) {
+        if (config?.usernameInputType === 'variable') {
             inputs.push({ id: 'username', type: 'text', isArray: false, required: true });
         }
-        if (config?.timeIsVariable) {
+        if (config?.timeInputType === 'variable') {
             inputs.push({ id: 'time', type: 'text', isArray: false, required: false });
         }
-        if (config?.profilePicIsVariable) {
+        if (config?.profilePicInputType === 'variable') {
             inputs.push({ id: 'profile-pic', type: 'image', isArray: false, required: false });
         }
-        if (config?.messagesIsVariable) {
+        if (config?.messagesInputType === 'variable') {
             inputs.push({ id: 'messages', type: 'object', isArray: true, required: true });
         }
-        if (config?.imageAttachmentIsVariable) {
+        if (config?.imageAttachmentInputType === 'variable') {
             inputs.push({ id: 'image-attachment', type: 'image', isArray: false, required: false });
         }
         // iMessage-specific
         if (config?.platform === 'imessage') {
-            if (config.imessage?.showReadReceipt && config.imessage?.readReceiptTimeIsVariable) {
+            if (config.imessageShowReadReceipt && config.imessageReadReceiptTimeInputType === 'variable') {
                 inputs.push({ id: 'read-receipt-time', type: 'text', isArray: false, required: false });
             }
-            if (config.imessage?.unreadBadgeIsVariable) {
+            if (config.imessageUnreadBadgeInputType === 'variable') {
                 inputs.push({ id: 'unread-badge', type: 'text', isArray: false, required: false });
             }
-            if (config.imessage?.messageHeaderTimeIsVariable) {
+            if (config.imessageMessageHeaderTimeInputType === 'variable') {
                 inputs.push({ id: 'message-header-time', type: 'text', isArray: false, required: false });
             }
         }

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

@@ -1,5 +1,5 @@
-type CustomModelOutputType = 'image' | 'video' | 'audio';
-interface CustomModelInputParam {
+export type CustomModelOutputType = 'image' | 'video' | 'audio';
+export interface CustomModelInputParam {
     name: string;
     type: string;
     required: boolean;
@@ -14,6 +14,5 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     apiKey: string | undefined;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type CustomModelConfig = typeof definition.defaults;

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

@@ -3,6 +3,5 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     deduplication: DeduplicationLevel;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type DeduplicateConfig = typeof definition.defaults;

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

@@ -1,3 +1,4 @@
+import { type InputType } from './types';
 type IndexExpression = {
     type: 'single';
     index: number;
@@ -12,14 +13,13 @@ type IndexExpression = {
 interface DestructureSelection {
     portId: string;
     indexExpr: IndexExpression;
-    isVariable?: boolean;
+    inputType?: InputType;
     propertyPath?: string;
 }
 declare const definition: import("./types").NodeDefinition<"generator", {
     selections: DestructureSelection[];
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export type { DestructureSelection, IndexExpression };
-export type DestructureConfig = typeof definition.defaults;

package/dist/automations/nodes/destructure.js

@@ -40,7 +40,7 @@ const definition = (0, types_1.defineNode)({
         }
         for (const selection of selections) {
             // If variable, add input port for index expression
-            if (selection.isVariable) {
+            if (selection.inputType === 'variable') {
                 inputs.push({
                     id: `idx-${selection.portId}`,
                     type: 'text',

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

@@ -17,7 +17,6 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     exposeIndex: boolean;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export type { ForEachOutputProperty, ForEachInputPort };
-export type ForEachConfig = typeof definition.defaults;

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

@@ -9,8 +9,7 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     apiKey: string | undefined;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export { isEditModel };
 export type { ImageGenerationTextModel, ImageGenerationEditModel, ImageGenerationModel };
-export type GenerateImageConfig = typeof definition.defaults;

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

@@ -9,8 +9,7 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     apiKey: string | undefined;
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export { isImageToVideoModel };
 export type { VideoGenerationTextToVideoModel, VideoGenerationImageToVideoModel, VideoGenerationModel };
-export type GenerateVideoConfig = typeof definition.defaults;

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

@@ -15,8 +15,7 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     passthroughInputs: IfPassthroughInput[];
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
 export { IfLogicOperators };
 export type { IfLogicOperator, IfBooleanInput, IfPassthroughInput };
-export type IfConfig = typeof definition.defaults;

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

@@ -1,5 +1,36 @@
-import type { NodeOutputValues } from '../types';
-import type { ImageEditorNodeConfig } from '../../render/types';
+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;
@@ -11,23 +42,5 @@ declare const definition: import("./types").NodeDefinition<"generator", {
     };
     outputMode: "per-input";
     selectionMode: null;
-}>;
+}, false>;
 export default definition;
-export type ImageComposerConfig = typeof definition.defaults;
-/**
- * Input to the image-composer node executor
- */
-export interface ImageEditorNodeInput extends Record<string, unknown> {
-    type: 'image-composer';
-    config: ImageEditorNodeConfig;
-    imageUrls: Record<string, string>;
-    textValues: Record<string, string>;
-}
-/**
- * Output from the image-composer node executor
- */
-export interface ImageEditorNodeOutput extends Record<string, unknown>, NodeOutputValues {
-    width?: number;
-    height?: number;
-    aspectRatio?: string;
-}

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

@@ -91,5 +91,45 @@ const definition = (0, types_1.defineNode)({
             ],
         };
     },
+    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;