@scenario-labs/sdk 2.4.0 → 2.6.0

package/src/lib/workflow_converter.ts

@@ -52,7 +52,14 @@ export type WorkflowEditorNode =
   | {
       id: string;
       type: 'sliceAssets';
-      data: NodeCommonData & { from?: number | string; count?: number | string };
+      data: NodeCommonData & {
+        from?: number | string;
+        count?: number | string;
+        isRandomize?: boolean;
+        randomSeed?: string;
+        isSeedLocked?: boolean;
+        value?: string;
+      };
     }
   | { id: string; type: 'forEach'; data: NodeCommonData }
   | { id: string; type: 'forEachEnd'; data: NodeCommonData & { parentNodeId?: string } }
@@ -561,6 +568,50 @@ function getOutputHandleVarName(targetNodeId: string, handleName: string): strin
   return ['output', 'allOutputs'].includes(handleName) ? targetNodeId : `${targetNodeId}_${handleName}`;
 }
 
+function getIsSliceAssetsItemsSourceHandle(nodeId: string, sourceHandle: string | null | undefined): boolean {
+  return sourceHandle === `${nodeId}-source-items` || sourceHandle === `${nodeId}-source-assets`;
+}
+
+/**
+ * Builds the concat variables and flow inputs for a list-concatenating node
+ * (groupItems, sliceAssets in randomize mode) from its incoming edges.
+ * `getVarName` maps a target node id + output handle name to the variable name,
+ * which differs between callers.
+ */
+function collectConcatVarsAndInputs(
+  edges: WorkflowEditorEdge[],
+  ctx: SourceRefContext,
+  getVarName: (targetNodeId: string, handleName: string) => string,
+): { variables: ConcatVariable[]; flowInputs: WorkflowEditorFlowInput[] } {
+  const { nodes, inputNodeIds } = ctx;
+  const variables: ConcatVariable[] = [];
+  const flowInputs: WorkflowEditorFlowInput[] = [];
+
+  for (const edge of edges) {
+    const targetNode = nodes.find((n) => n.id === edge.target);
+    if (!targetNode) continue;
+    const ref = getSourceRef(edge, ctx);
+    if (!ref) continue;
+    const outHandle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
+    const outHandleName = outHandle?.name ?? 'output';
+    const varName = getVarName(targetNode.id, outHandleName);
+    const isArr =
+      (targetNode.type === 'asset' && !!(targetNode.data as { isMultiple?: boolean }).isMultiple) ||
+      targetNode.type === 'groupItems' ||
+      targetNode.type === 'sliceAssets' ||
+      outHandleName === 'allOutputs';
+    const isRequired =
+      inputNodeIds.includes(targetNode.id) ?
+        (targetNode.type === 'asset' && !!(targetNode.data as { isRequired?: boolean }).isRequired) ||
+        ['firstFrame', 'lastFrame'].includes(outHandleName)
+      : true;
+    variables.push({ name: varName, isArray: isArr, isRequired });
+    flowInputs.push({ name: varName, type: isArr ? 'file_array' : 'file', ref });
+  }
+
+  return { variables, flowInputs };
+}
+
 function setOrPushFlowInput(
   flowInputs: WorkflowEditorFlowInput[],
   existingIndex: number,
@@ -1522,32 +1573,12 @@ export function convertWorkflowEditorToFlow(
       // GroupItems -> array concatenation
       // ------------------------------------
     } else if (node.type === 'groupItems') {
-      const flowInputs: WorkflowEditorFlowInput[] = [];
-      const variables: ConcatVariable[] = [];
       const conditionalHandleId = getConditionalInputHandleId(node.id);
-
-      for (const edge of incomingEdges) {
-        if (edge.sourceHandle === conditionalHandleId) continue;
-        const targetNode = nodes.find((n) => n.id === edge.target);
-        if (!targetNode) continue;
-        const ref = getSourceRef(edge, ctx);
-        if (!ref) continue;
-        const outHandle = targetNode.data.outputHandles?.find((h) => h.id === edge.targetHandle);
-        const outHandleName = outHandle?.name ?? 'output';
-        const varName = `${targetNode.id}_${outHandleName}`;
-        const isArr =
-          (targetNode.type === 'asset' && !!(targetNode.data as { isMultiple?: boolean }).isMultiple) ||
-          targetNode.type === 'groupItems' ||
-          targetNode.type === 'sliceAssets' ||
-          outHandleName === 'allOutputs';
-        const isRequired =
-          inputNodeIds.includes(targetNode.id) ?
-            (targetNode.type === 'asset' && !!(targetNode.data as { isRequired?: boolean }).isRequired) ||
-            ['firstFrame', 'lastFrame'].includes(outHandleName)
-          : true;
-        variables.push({ name: varName, isArray: isArr, isRequired });
-        flowInputs.push({ name: varName, type: isArr ? 'file_array' : 'file', ref });
-      }
+      const { variables, flowInputs } = collectConcatVarsAndInputs(
+        incomingEdges.filter((e) => e.sourceHandle !== conditionalHandleId),
+        ctx,
+        (targetNodeId, handleName) => `${targetNodeId}_${handleName}`,
+      );
 
       const orderedValues = convertValueToList((node.data as { value?: string }).value ?? '');
       variables.sort((a, b) => orderedValues.indexOf(a.name) - orderedValues.indexOf(b.name));
@@ -1561,20 +1592,50 @@ export function convertWorkflowEditorToFlow(
       });
 
       // ------------------------------------
-      // SliceAssets -> slice(list, from, from+count)
+      // SliceAssets -> slice(list, from, from+count) or randomSample(list, count, seed)
       // ------------------------------------
     } else if (node.type === 'sliceAssets') {
-      const assetsEdge = incomingEdges.find((e) => e.sourceHandle === `${node.id}-source-assets`);
-      if (!assetsEdge) {
-        flow.push({ id: flowId, type: 'transform', logic: { transform: '[]' } });
+      const sliceData = node.data as {
+        from?: number | string;
+        count?: number | string;
+        isRandomize?: boolean;
+        randomSeed?: string;
+        isSeedLocked?: boolean;
+      };
+      const conditionalHandleId = getConditionalInputHandleId(node.id);
+      const itemsEdges = incomingEdges.filter(
+        (e) =>
+          e.sourceHandle !== conditionalHandleId &&
+          getIsSliceAssetsItemsSourceHandle(node.id, e.sourceHandle),
+      );
+
+      if (sliceData.isRandomize) {
+        const { variables, flowInputs } = collectConcatVarsAndInputs(itemsEdges, ctx, getOutputHandleVarName);
+        flowInputs.push(...collectConditionalConnectionInputs(incomingEdges, node.id, ctx));
+
+        const count = Math.max(1, parseInt(String(sliceData.count ?? ''), 10) || 1);
+        const listExpr = buildConcatArrayTransform(variables);
+        const transform =
+          sliceData.isSeedLocked === true ?
+            `randomSample(${listExpr}, ${count}, ${parseInt(String(sliceData.randomSeed ?? ''), 10) || 0})`
+          : `randomSample(${listExpr}, ${count})`;
+
+        flow.push({
+          id: flowId,
+          type: 'transform',
+          logic: { transform },
+          inputs: flowInputs.length > 0 ? flowInputs : undefined,
+        });
       } else {
-        const targetNode = nodes.find((n) => n.id === assetsEdge.target);
-        if (targetNode) {
-          const ref = getSourceRef(assetsEdge, ctx);
-          if (ref) {
+        const assetsEdge = itemsEdges[0];
+        if (!assetsEdge) {
+          flow.push({ id: flowId, type: 'transform', logic: { transform: '[]' } });
+        } else {
+          const targetNode = nodes.find((n) => n.id === assetsEdge.target);
+          const ref = targetNode ? getSourceRef(assetsEdge, ctx) : undefined;
+          if (targetNode && ref) {
             const outHandle = targetNode.data.outputHandles?.find((h) => h.id === assetsEdge.targetHandle);
             const varName = getOutputHandleVarName(targetNode.id, outHandle?.name ?? 'output');
-            const sliceData = node.data as { from?: number | string; count?: number | string };
             const from = parseInt(String(sliceData.from ?? ''), 10) || 0;
             const count = parseInt(String(sliceData.count ?? ''), 10) || 0;
             const transform =