@uploadista/flow-utility-nodes 0.0.3

package/.turbo/turbo-build.log

@@ -0,0 +1,5 @@
+
+
+> @uploadista/flow-utility-nodes@0.0.2 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/flow/utility/nodes
+> tsc -b
+

package/.turbo/turbo-check.log

@@ -0,0 +1,5 @@
+
+> @uploadista/flow-utility-nodes@ check /Users/denislaboureyras/Documents/uploadista/dev/uploadista/packages/uploadista/flow/utility-nodes
+> biome check --write ./src
+
+Checked 10 files in 48ms. No fixes applied.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 uploadista
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,289 @@
+# @uploadista/flow-utility-nodes
+
+Flow utility nodes for Uploadista. Provides conditional routing, merging, multiplexing, and data transformation operations in upload pipelines.
+
+## Overview
+
+Utility nodes enable complex flow logic without custom code:
+
+- **Conditional Node**: Route uploads based on file properties
+- **Merge Node**: Combine multiple inputs into one
+- **Multiplex Node**: Split single input across multiple outputs
+- **Zip Node**: Archive multiple files together
+
+Perfect for building sophisticated upload workflows.
+
+## Installation
+
+```bash
+npm install @uploadista/flow-utility-nodes
+# or
+pnpm add @uploadista/flow-utility-nodes
+```
+
+## Quick Start
+
+```typescript
+import { conditionalNode, mergeNode, multiplexNode, zipNode } from "@uploadista/flow-utility-nodes";
+import { Effect } from "effect";
+
+// Route based on file properties
+const flow = {
+  nodes: [
+    { id: "input", type: "input" },
+    {
+      id: "router",
+      type: "conditional",
+      params: {
+        field: "mimeType",
+        operator: "contains",
+        value: "image",
+      },
+    },
+    { id: "output", type: "output" },
+  ],
+  edges: [
+    { from: "input", to: "router" },
+    { from: "router", to: "output" },
+  ],
+};
+```
+
+## Features
+
+- ✅ **Conditional Routing**: Route based on file properties
+- ✅ **Data Merging**: Combine multiple streams
+- ✅ **Multiplexing**: Split to multiple outputs
+- ✅ **Type Safe**: Full TypeScript support
+- ✅ **No Custom Code**: Visual flow building
+
+## Node Types
+
+### Conditional Node
+
+Route inputs based on file properties.
+
+**Parameters**:
+```typescript
+{
+  field: "mimeType" | "size" | "width" | "height" | "extension",
+  operator: "equals" | "notEquals" | "greaterThan" | "lessThan" | "contains" | "startsWith",
+  value: string | number
+}
+```
+
+**Example**: Route images to resize, documents to compress
+```typescript
+{
+  type: "conditional",
+  params: {
+    field: "mimeType",
+    operator: "contains",
+    value: "image",
+  },
+}
+```
+
+### Merge Node
+
+Combine multiple inputs into batch.
+
+**Parameters**:
+```typescript
+{
+  strategy: "concat" | "batch",
+  separator?: string,
+  inputCount: 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
+}
+```
+
+**Example**: Batch 5 uploads before processing
+```typescript
+{
+  type: "merge",
+  params: {
+    strategy: "batch",
+    inputCount: 5,
+  },
+}
+```
+
+### Multiplex Node
+
+Split input to multiple independent paths.
+
+**Parameters**:
+```typescript
+{
+  outputCount: 2 | 3 | 4 | 5
+}
+```
+
+**Example**: Send to S3 and archive simultaneously
+```typescript
+{
+  type: "multiplex",
+  params: {
+    outputCount: 2,
+  },
+}
+```
+
+### Zip Node
+
+Archive multiple files (see `@uploadista/flow-utility-zipjs`).
+
+## Use Cases
+
+### Case 1: Smart Routing
+
+```
+Input → Conditional
+        ├─ Image → Resize
+        ├─ PDF → Compress
+        └─ Document → Archive
+        → Output
+```
+
+### Case 2: Batch Processing
+
+```
+Input 1 ┐
+Input 2 ├─ Merge (batch 3) → Process → Output
+Input 3 ┘
+```
+
+### Case 3: Multi-Destination
+
+```
+Input → Multiplex ├─ Store to S3
+                  ├─ Archive to GCS
+                  └─ Notify Webhook
+```
+
+## API Reference
+
+All nodes exported from main entry point.
+
+```typescript
+import {
+  conditionalNode,
+  mergeNode,
+  multiplexNode,
+  zipNode,
+} from "@uploadista/flow-utility-nodes";
+```
+
+## Examples
+
+### Example 1: Image/Document Routing
+
+```typescript
+const flow = {
+  nodes: [
+    { id: "input", type: "input" },
+    {
+      id: "router",
+      type: "conditional",
+      params: {
+        field: "mimeType",
+        operator: "contains",
+        value: "image",
+      },
+    },
+    { id: "resize", type: "resize", params: { width: 800 } },
+    { id: "s3", type: "s3", params: { bucket: "images" } },
+    { id: "pdf-store", type: "s3", params: { bucket: "documents" } },
+    { id: "output", type: "output" },
+  ],
+  edges: [
+    { from: "input", to: "router" },
+    { from: "router", true: "resize", false: "pdf-store" },
+    { from: "resize", to: "s3" },
+    { from: "s3", to: "output" },
+    { from: "pdf-store", to: "output" },
+  ],
+};
+```
+
+### Example 2: Batch Processing
+
+```typescript
+const batchFlow = {
+  nodes: [
+    { id: "input1", type: "input" },
+    { id: "input2", type: "input" },
+    { id: "input3", type: "input" },
+    {
+      id: "merge",
+      type: "merge",
+      params: { strategy: "batch", inputCount: 3 },
+    },
+    { id: "process", type: "custom", params: {} },
+    { id: "output", type: "output" },
+  ],
+  edges: [
+    { from: "input1", to: "merge" },
+    { from: "input2", to: "merge" },
+    { from: "input3", to: "merge" },
+    { from: "merge", to: "process" },
+    { from: "process", to: "output" },
+  ],
+};
+```
+
+### Example 3: Multi-Path Distribution
+
+```typescript
+const multiPath = {
+  nodes: [
+    { id: "input", type: "input" },
+    { id: "split", type: "multiplex", params: { outputCount: 3 } },
+    { id: "s3", type: "s3", params: { bucket: "primary" } },
+    { id: "gcs", type: "gcs", params: { bucket: "backup" } },
+    { id: "archive", type: "zip", params: {} },
+    { id: "output", type: "output" },
+  ],
+  edges: [
+    { from: "input", to: "split" },
+    { from: "split", index: 0, to: "s3" },
+    { from: "split", index: 1, to: "gcs" },
+    { from: "split", index: 2, to: "archive" },
+    { from: "s3", to: "output" },
+    { from: "gcs", to: "output" },
+    { from: "archive", to: "output" },
+  ],
+};
+```
+
+## Configuration
+
+Nodes configured via `params` object in flow definition:
+
+```typescript
+{
+  id: "node-id",
+  type: "conditional",
+  params: {
+    field: "mimeType",
+    operator: "contains",
+    value: "image",
+  },
+}
+```
+
+## Related Packages
+
+- [@uploadista/core](../../core) - Core flow types
+- [@uploadista/flow-utility-zipjs](../zipjs) - Archive node
+- [@uploadista/flow-images-nodes](../images/nodes) - Image utilities
+- [@uploadista/server](../../servers/server) - Upload server
+
+## License
+
+See [LICENSE](../../../LICENSE) in the main repository.
+
+## See Also
+
+- [FLOW_NODES.md](../FLOW_NODES.md) - Complete node gallery
+- [Server Setup Guide](../../../SERVER_SETUP.md) - Flow integration

package/dist/conditional-node.d.ts

@@ -0,0 +1,25 @@
+import { type FlowFile } from "@uploadista/flow-core";
+import { z } from "zod";
+export declare const conditionalParamsSchema: z.ZodObject<{
+    field: z.ZodEnum<{
+        mimeType: "mimeType";
+        size: "size";
+        width: "width";
+        height: "height";
+        extension: "extension";
+    }>;
+    operator: z.ZodEnum<{
+        equals: "equals";
+        notEquals: "notEquals";
+        greaterThan: "greaterThan";
+        lessThan: "lessThan";
+        contains: "contains";
+        startsWith: "startsWith";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    trueBranch: z.ZodString;
+    falseBranch: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ConditionalParams = z.infer<typeof conditionalParamsSchema>;
+export declare function createConditionalNode(id: string, { field, operator, value, trueBranch, falseBranch }: ConditionalParams): import("@uploadista/flow-core").FlowNode<FlowFile, FlowFile>;
+//# sourceMappingURL=conditional-node.d.ts.map

package/dist/conditional-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-node.d.ts","sourceRoot":"","sources":["../src/conditional-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAGd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;iBAalC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAIxE,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,EAAE,iBAAiB,gEAmBvE"}

package/dist/conditional-node.js

@@ -0,0 +1,34 @@
+import { createFlowNode, flowFileSchema, NodeType, } from "@uploadista/flow-core";
+import { z } from "zod";
+export const conditionalParamsSchema = z.object({
+    field: z.enum(["mimeType", "size", "width", "height", "extension"]),
+    operator: z.enum([
+        "equals",
+        "notEquals",
+        "greaterThan",
+        "lessThan",
+        "contains",
+        "startsWith",
+    ]),
+    value: z.union([z.string(), z.number()]),
+    trueBranch: z.string(),
+    falseBranch: z.string().optional(),
+});
+// Define schemas for input and output
+export function createConditionalNode(id, { field, operator, value, trueBranch, falseBranch }) {
+    return createFlowNode({
+        id,
+        name: "Conditional Router",
+        description: `Routes flow based on ${field} ${operator} ${value}`,
+        type: NodeType.conditional,
+        inputSchema: flowFileSchema,
+        outputSchema: flowFileSchema,
+        condition: { field, operator, value },
+        branches: [trueBranch, falseBranch].filter((branch) => branch !== undefined),
+        run: async ({ data }) => {
+            // The actual routing logic is handled by the flow engine
+            // This node just passes through the data
+            return data;
+        },
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./conditional-node";
+export * from "./merge-node";
+export * from "./multiplex-node";
+export * from "./zip-node";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./nodes/conditional-node";
+export * from "./nodes/merge-node";
+export * from "./nodes/multiplex-node";
+export * from "./nodes/zip-node";

package/dist/merge-node.d.ts

@@ -0,0 +1,12 @@
+import { type FlowFile, type FlowFileBatch } from "@uploadista/flow-core";
+import { z } from "zod";
+export declare const mergeParamsSchema: z.ZodObject<{
+    strategy: z.ZodDefault<z.ZodEnum<{
+        concat: "concat";
+        batch: "batch";
+    }>>;
+    separator: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+}, z.core.$strip>;
+export type MergeParams = z.infer<typeof mergeParamsSchema>;
+export declare function createMergeNode(id: string, { strategy, separator: _separator }: MergeParams): import("@uploadista/flow-core").FlowNode<Record<string, FlowFile | FlowFileBatch>, FlowFile | FlowFileBatch>;
+//# sourceMappingURL=merge-node.d.ts.map

package/dist/merge-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-node.d.ts","sourceRoot":"","sources":["../src/merge-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,aAAa,EAInB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;;;;iBAG5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAO5D,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EACV,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE,WAAW,gHAwEjD"}

package/dist/merge-node.js

@@ -0,0 +1,77 @@
+import { createFlowNode, flowDataSchema, isFlowFile, NodeType, } from "@uploadista/flow-core";
+import { z } from "zod";
+export const mergeParamsSchema = z.object({
+    strategy: z.enum(["concat", "batch"]).default("batch"),
+    separator: z.string().default("\n").optional(),
+});
+// Define schemas for input and output
+const inputSchema = z.record(z.string(), flowDataSchema);
+const outputSchema = flowDataSchema;
+export function createMergeNode(id, { strategy, separator: _separator }) {
+    return createFlowNode({
+        id,
+        name: "Merge Files",
+        description: `Merges multiple files using ${strategy} strategy`,
+        type: NodeType.merge,
+        inputSchema,
+        outputSchema,
+        multiInput: true,
+        run: async ({ data: inputs }) => {
+            if (!inputs) {
+                throw new Error("No inputs provided to merge node");
+            }
+            const inputFiles = [];
+            // Collect all input files
+            for (const [_sourceId, input] of Object.entries(inputs)) {
+                if (isFlowFile(input)) {
+                    // Handle single FlowFile
+                    inputFiles.push(input);
+                }
+                else {
+                    // Handle FlowFileBatch
+                    inputFiles.push(...input.files);
+                }
+            }
+            if (inputFiles.length === 0) {
+                throw new Error("No files to merge");
+            }
+            if (strategy === "batch") {
+                // Return as a batch
+                return {
+                    files: inputFiles,
+                    metadata: {
+                        batchId: crypto.randomUUID(),
+                        totalSize: inputFiles.reduce((sum, file) => sum + file.metadata.size, 0),
+                        fileCount: inputFiles.length,
+                    },
+                };
+            }
+            else if (strategy === "concat") {
+                // Concatenate all files into one
+                const inputBytesArray = [];
+                let totalSize = 0;
+                for (const file of inputFiles) {
+                    inputBytesArray.push(file.inputBytes);
+                    totalSize += file.inputBytes.length;
+                }
+                const mergedInputBytes = new Uint8Array(totalSize);
+                let offset = 0;
+                for (const inputBytes of inputBytesArray) {
+                    mergedInputBytes.set(inputBytes, offset);
+                    offset += inputBytes.length;
+                }
+                return {
+                    path: `merged_${crypto.randomUUID()}`,
+                    inputBytes: mergedInputBytes,
+                    metadata: {
+                        mimeType: "application/octet-stream",
+                        size: totalSize,
+                        originalName: `merged_${inputFiles.length}_files`,
+                        extension: "bin",
+                    },
+                };
+            }
+            throw new Error(`Unknown merge strategy: ${strategy}`);
+        },
+    });
+}

package/dist/multiplex-node.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+export declare const multiplexParamsSchema: z.ZodObject<{
+    outputCount: z.ZodNumber;
+    strategy: z.ZodDefault<z.ZodEnum<{
+        split: "split";
+        copy: "copy";
+    }>>;
+}, z.core.$strip>;
+export type MultiplexParams = z.infer<typeof multiplexParamsSchema>;
+export declare function createMultiplexNode(id: string, { outputCount, strategy }: MultiplexParams): import("@uploadista/flow-core").FlowNode<{
+    path: string;
+    inputBytes: Uint8Array<ArrayBufferLike>;
+    metadata: {
+        mimeType: string;
+        size: number;
+        width?: number | undefined;
+        height?: number | undefined;
+        format?: string | undefined;
+        originalName?: string | undefined;
+        extension?: string | undefined;
+    };
+}, {
+    files: {
+        path: string;
+        inputBytes: Uint8Array<ArrayBufferLike>;
+        metadata: {
+            mimeType: string;
+            size: number;
+            width?: number | undefined;
+            height?: number | undefined;
+            format?: string | undefined;
+            originalName?: string | undefined;
+            extension?: string | undefined;
+        };
+    }[];
+    metadata?: {
+        batchId: string;
+        totalSize: number;
+        fileCount: number;
+    } | undefined;
+}>;
+//# sourceMappingURL=multiplex-node.d.ts.map

package/dist/multiplex-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiplex-node.d.ts","sourceRoot":"","sources":["../src/multiplex-node.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qBAAqB;;;;;;iBAGhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAIpE,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoE3C"}

package/dist/multiplex-node.js

@@ -0,0 +1,67 @@
+import { createFlowNode, flowFileBatchSchema, flowFileSchema, NodeType, } from "@uploadista/flow-core";
+import { z } from "zod";
+export const multiplexParamsSchema = z.object({
+    outputCount: z.number().min(1).max(10),
+    strategy: z.enum(["copy", "split"]).default("copy"),
+});
+// Define schemas for input and output
+export function createMultiplexNode(id, { outputCount, strategy }) {
+    return createFlowNode({
+        id,
+        name: "Multiplex",
+        description: `Splits input into ${outputCount} parallel outputs using ${strategy} strategy`,
+        type: NodeType.multiplex,
+        inputSchema: flowFileSchema,
+        outputSchema: flowFileBatchSchema,
+        multiOutput: true,
+        run: async ({ data }) => {
+            if (strategy === "copy") {
+                // Copy the same file to multiple outputs
+                const files = Array.from({ length: outputCount }, (_, index) => ({
+                    path: `${data.path}_copy_${index}`,
+                    inputBytes: data.inputBytes,
+                    metadata: {
+                        ...data.metadata,
+                        originalName: `${data.metadata.originalName || data.path}_copy_${index}`,
+                    },
+                }));
+                return {
+                    files,
+                    metadata: {
+                        batchId: crypto.randomUUID(),
+                        totalSize: files.length * data.metadata.size,
+                        fileCount: files.length,
+                    },
+                };
+            }
+            else if (strategy === "split") {
+                // Split the file into chunks
+                const chunkSize = Math.ceil(data.inputBytes.length / outputCount);
+                const files = [];
+                for (let i = 0; i < outputCount; i++) {
+                    const start = i * chunkSize;
+                    const end = Math.min(start + chunkSize, data.inputBytes.length);
+                    const chunk = data.inputBytes.subarray(start, end);
+                    files.push({
+                        path: `${data.path}_part_${i}`,
+                        inputBytes: chunk,
+                        metadata: {
+                            ...data.metadata,
+                            size: chunk.length,
+                            originalName: `${data.metadata.originalName || data.path}_part_${i}`,
+                        },
+                    });
+                }
+                return {
+                    files,
+                    metadata: {
+                        batchId: crypto.randomUUID(),
+                        totalSize: data.inputBytes.length,
+                        fileCount: files.length,
+                    },
+                };
+            }
+            throw new Error(`Unknown multiplex strategy: ${strategy}`);
+        },
+    });
+}

package/dist/nodes/conditional-node.d.ts

@@ -0,0 +1,5 @@
+import { type UploadFile } from "@uploadista/core/types";
+import { Effect } from "effect";
+import type { ConditionalParams } from "@/types/conditional-node";
+export declare function createConditionalNode(id: string, { field, operator, value }: ConditionalParams): Effect.Effect<import("@uploadista/core").FlowNode<UploadFile, UploadFile, import("@uploadista/core").UploadistaError>, never, never>;
+//# sourceMappingURL=conditional-node.d.ts.map

package/dist/nodes/conditional-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-node.d.ts","sourceRoot":"","sources":["../../src/nodes/conditional-node.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,iBAAiB,wIAgB9C"}

package/dist/nodes/conditional-node.js

@@ -0,0 +1,19 @@
+import { completeNodeExecution, createFlowNode, NodeType, } from "@uploadista/core/flow";
+import { uploadFileSchema } from "@uploadista/core/types";
+import { Effect } from "effect";
+export function createConditionalNode(id, { field, operator, value }) {
+    return createFlowNode({
+        id,
+        name: "Conditional Router",
+        description: `Routes flow based on ${field} ${operator} ${value}`,
+        type: NodeType.conditional,
+        inputSchema: uploadFileSchema,
+        outputSchema: uploadFileSchema,
+        condition: { field, operator, value },
+        run: ({ data }) => {
+            // The actual routing logic is handled by the flow engine
+            // This node just passes through the data
+            return Effect.succeed(completeNodeExecution(data));
+        },
+    });
+}

package/dist/nodes/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./conditional-node";
+export * from "./merge-node";
+export * from "./multiplex-node";
+export * from "./zip-node";
+//# sourceMappingURL=index.d.ts.map

package/dist/nodes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/nodes/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/nodes/index.js

@@ -0,0 +1,4 @@
+export * from "./conditional-node";
+export * from "./merge-node";
+export * from "./multiplex-node";
+export * from "./zip-node";

package/dist/nodes/merge-node.d.ts

@@ -0,0 +1,7 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { type UploadFile } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { Effect } from "effect";
+import type { MergeParams } from "@/types/merge-node";
+export declare function createMergeNode(id: string, { strategy, separator: _separator }: MergeParams): Effect.Effect<import("@uploadista/core").FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer>;
+//# sourceMappingURL=merge-node.d.ts.map

package/dist/nodes/merge-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-node.d.ts","sourceRoot":"","sources":["../../src/nodes/merge-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAM1D,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAKtD,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EACV,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE,WAAW,oIA6FjD"}