@alpic80/rivet-core 1.19.1-aidon.1

package/dist/esm/model/nodes/IfNode.js

@@ -0,0 +1,124 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../NodeBase.js';
+import {} from '../DataValue.js';
+import { nanoid } from 'nanoid/non-secure';
+import { dedent } from 'ts-dedent';
+import { coerceType } from '../../utils/coerceType.js';
+export class IfNodeImpl extends NodeImpl {
+    static create = () => {
+        const chartNode = {
+            type: 'if',
+            title: 'If',
+            id: nanoid(),
+            data: {
+                // Legacy behavior is false
+                unconnectedControlFlowExcluded: true,
+            },
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 125,
+            },
+        };
+        return chartNode;
+    };
+    getInputDefinitions() {
+        return [
+            {
+                id: 'if',
+                title: 'If',
+                dataType: 'any',
+                description: 'If this is truthy, the value will be passed through the True port. Otherwise, it will be passed through the False port. An unconnected port is considered false.',
+            },
+            {
+                id: 'value',
+                title: 'Value',
+                dataType: 'any',
+                description: 'The value to pass through the True or False port. If unconnected, it will be undefined.',
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'output',
+                title: 'True',
+                dataType: 'any',
+                description: 'The `value` passed through if the condition is truthy.',
+            },
+            {
+                id: 'falseOutput',
+                title: 'False',
+                dataType: 'any',
+                description: 'The `value` passed through if the condition is falsy.',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Takes in a condition and a value. If the condition is truthy, the value is passed through the True port, and the False port is not ran.
+        If the condition is falsy, the value is passed through the False port, and the True port is not ran.
+      `,
+            infoBoxTitle: 'If Node',
+            contextMenuTitle: 'If',
+            group: ['Logic'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'toggle',
+                label: "Don't run unconnected value",
+                dataKey: 'unconnectedControlFlowExcluded',
+            },
+        ];
+    }
+    async process(inputData) {
+        const unconnectedValue = this.data.unconnectedControlFlowExcluded
+            ? { type: 'control-flow-excluded', value: undefined }
+            : { type: 'any', value: undefined };
+        const ifValue = inputData['if'];
+        const value = inputData['value'] ?? unconnectedValue;
+        const isFalse = {
+            output: {
+                type: 'control-flow-excluded',
+                value: undefined,
+            },
+            falseOutput: value,
+        };
+        if (!ifValue) {
+            return isFalse;
+        }
+        if (ifValue.type === 'control-flow-excluded') {
+            return isFalse;
+        }
+        if (ifValue.type === 'string' && !ifValue.value) {
+            return isFalse;
+        }
+        if (ifValue.type === 'boolean' && !ifValue.value) {
+            return isFalse;
+        }
+        if (ifValue.type === 'chat-message') {
+            const asString = coerceType(ifValue, 'string');
+            if (!asString) {
+                return isFalse;
+            }
+        }
+        if (ifValue.type.endsWith('[]')) {
+            const value = ifValue;
+            if (!value.value || value.value.length === 0) {
+                return isFalse;
+            }
+        }
+        return {
+            ['output']: value,
+            ['falseOutput']: {
+                type: 'control-flow-excluded',
+                value: undefined,
+            },
+        };
+    }
+}
+export const ifNode = nodeDefinition(IfNodeImpl, 'If');

package/dist/esm/model/nodes/ImageNode.js

@@ -0,0 +1,107 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../../index.js';
+import { base64ToUint8Array } from '../../utils/base64.js';
+import { expectType } from '../../utils/expectType.js';
+export class ImageNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'image',
+            title: 'Image',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                useDataInput: false,
+                mediaType: 'image/png',
+                useMediaTypeInput: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.useDataInput) {
+            inputDefinitions.push({
+                id: 'data',
+                title: 'Data',
+                dataType: 'binary',
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useMediaTypeInput) {
+            inputDefinitions.push({
+                id: 'mediaType',
+                title: 'Media Type',
+                dataType: 'string',
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'image',
+                title: 'Image',
+                dataType: 'image',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Media Type',
+                dataKey: 'mediaType',
+                options: [
+                    { value: 'image/png', label: 'PNG' },
+                    { value: 'image/jpeg', label: 'JPEG' },
+                    { value: 'image/gif', label: 'GIF' },
+                ],
+                useInputToggleDataKey: 'useMediaTypeInput',
+            },
+            {
+                type: 'imageBrowser',
+                label: 'Image',
+                dataKey: 'data',
+                useInputToggleDataKey: 'useDataInput',
+                mediaTypeDataKey: 'mediaType',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            contextMenuTitle: 'Image',
+            group: 'Data',
+            infoBoxTitle: 'Image Node',
+            infoBoxBody: 'Defines a static image for use with other nodes. Can convert a binary type into an image type.',
+        };
+    }
+    async process(inputData, context) {
+        let data;
+        if (this.chartNode.data.useDataInput) {
+            data = expectType(inputData['data'], 'binary');
+        }
+        else {
+            const dataRef = this.data.data?.refId;
+            if (!dataRef) {
+                throw new Error('No data ref');
+            }
+            const encodedData = context.project.data?.[dataRef];
+            if (!encodedData) {
+                throw new Error(`No data at ref ${dataRef}`);
+            }
+            data = base64ToUint8Array(encodedData);
+        }
+        const mediaType = this.chartNode.data.useMediaTypeInput
+            ? expectType(inputData['mediaType'], 'string')
+            : this.chartNode.data.mediaType;
+        return {
+            ['image']: {
+                type: 'image',
+                value: { mediaType: mediaType, data },
+            },
+        };
+    }
+}
+export const imageNode = nodeDefinition(ImageNodeImpl, 'Image');

package/dist/esm/model/nodes/JoinNode.js

@@ -0,0 +1,135 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../NodeBase.js';
+import { isArrayDataValue } from '../DataValue.js';
+import { nanoid } from 'nanoid/non-secure';
+import { coerceType, coerceTypeOptional, inferType } from '../../utils/coerceType.js';
+import {} from '../GraphProcessor.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import { handleEscapeCharacters } from '../../utils/index.js';
+export class JoinNodeImpl extends NodeImpl {
+    static create = () => {
+        const chartNode = {
+            type: 'join',
+            title: 'Join',
+            id: nanoid(),
+            data: {
+                flatten: true,
+                joinString: '\n',
+            },
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 150,
+            },
+        };
+        return chartNode;
+    };
+    getInputDefinitions(connections) {
+        const inputs = [];
+        const inputCount = this.#getInputPortCount(connections);
+        if (this.data.useJoinStringInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'joinString',
+                title: 'Join String',
+            });
+        }
+        for (let i = 1; i <= inputCount; i++) {
+            inputs.push({
+                dataType: 'string',
+                id: `input${i}`,
+                title: `Input ${i}`,
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'string',
+                id: 'output',
+                title: 'Joined',
+            },
+        ];
+    }
+    #getInputPortCount(connections) {
+        const inputNodeId = this.chartNode.id;
+        const inputConnections = connections.filter((connection) => connection.inputNodeId === inputNodeId && connection.inputId.startsWith('input'));
+        let maxInputNumber = 0;
+        for (const connection of inputConnections) {
+            const messageNumber = parseInt(connection.inputId.replace('input', ''), 10);
+            if (messageNumber > maxInputNumber) {
+                maxInputNumber = messageNumber;
+            }
+        }
+        return maxInputNumber + 1;
+    }
+    getEditors() {
+        return [
+            {
+                type: 'toggle',
+                label: 'Flatten',
+                dataKey: 'flatten',
+            },
+            {
+                type: 'code',
+                label: 'Join String',
+                dataKey: 'joinString',
+                useInputToggleDataKey: 'useJoinStringInput',
+                language: 'plaintext',
+            },
+        ];
+    }
+    getBody() {
+        return this.data.useJoinStringInput
+            ? '(Join value is input)'
+            : this.data.joinString === '\n'
+                ? '(New line)'
+                : this.data.joinString === '\t'
+                    ? '(Tab)'
+                    : this.data.joinString === ' '
+                        ? '(Space)'
+                        : this.data.joinString;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Takes an array of strings, and joins them using the configured delimiter.
+
+        Defaults to a newline.
+      `,
+            infoBoxTitle: 'Join Node',
+            contextMenuTitle: 'Join',
+            group: ['Text'],
+        };
+    }
+    async process(inputs) {
+        const joinString = this.data.useJoinStringInput
+            ? coerceTypeOptional(inputs['joinString'], 'string') ?? this.data.joinString
+            : this.data.joinString;
+        const normalizedJoinString = handleEscapeCharacters(joinString);
+        const inputKeys = Object.keys(inputs).filter((key) => key.startsWith('input'));
+        const inputValueStrings = [];
+        for (let i = 1; i <= inputKeys.length; i++) {
+            const inputValue = inputs[`input${i}`];
+            if (isArrayDataValue(inputValue) && this.data.flatten) {
+                for (const value of inputValue.value) {
+                    inputValueStrings.push(coerceType(inferType(value), 'string'));
+                }
+            }
+            else if (inputValue) {
+                inputValueStrings.push(coerceType(inputValue, 'string'));
+            }
+        }
+        const outputValue = inputValueStrings.join(normalizedJoinString);
+        return {
+            ['output']: {
+                type: 'string',
+                value: outputValue,
+            },
+        };
+    }
+}
+export const joinNode = nodeDefinition(JoinNodeImpl, 'Coalesce');

package/dist/esm/model/nodes/ListGraphsNode.js

@@ -0,0 +1,61 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { dedent, newId } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class ListGraphsNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: newId(),
+            type: 'listGraphs',
+            title: 'List Graphs',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {},
+        };
+    }
+    getInputDefinitions() {
+        return [];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'graphs',
+                title: 'Graphs',
+                dataType: 'graph-reference[]',
+            },
+            {
+                id: 'graph-names',
+                title: 'Graph Names',
+                dataType: 'string[]',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Lists all graphs in the project.
+      `,
+            infoBoxTitle: 'List Graphs Node',
+            contextMenuTitle: 'List Graphs',
+            group: ['Input/Output'],
+        };
+    }
+    getEditors() {
+        return [];
+    }
+    async process(_inputs, context) {
+        const graphs = Object.values(context.project.graphs);
+        return {
+            ['graphs']: {
+                type: 'graph-reference[]',
+                value: graphs.map((graph) => ({
+                    graphId: graph.metadata.id ?? '',
+                    graphName: graph.metadata.name ?? '',
+                })),
+            },
+            ['graph-names']: {
+                type: 'string[]',
+                value: graphs.map((graph) => graph.metadata.name ?? ''),
+            },
+        };
+    }
+}
+export const listGraphsNode = nodeDefinition(ListGraphsNodeImpl, 'List Graphs');

package/dist/esm/model/nodes/LoadDatasetNode.js

@@ -0,0 +1,83 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { coerceTypeOptional, dedent, newId } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class LoadDatasetNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: newId(),
+            type: 'loadDataset',
+            title: 'Load Dataset',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                datasetId: '',
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputs = [];
+        if (this.data.useDatasetIdInput) {
+            inputs.push({
+                id: 'datasetId',
+                title: 'Dataset ID',
+                dataType: 'string',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'dataset',
+                title: 'Dataset',
+                dataType: 'object[]',
+            },
+            {
+                id: 'datasetId_out',
+                title: 'Dataset ID',
+                dataType: 'string',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Loads a dataset with the provided ID. If the dataset does not exist, it throws an error.
+      `,
+            infoBoxTitle: 'Load Dataset Node',
+            contextMenuTitle: 'Load Dataset',
+            group: ['Input/Output'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'datasetSelector',
+                label: 'Dataset',
+                dataKey: 'datasetId',
+                useInputToggleDataKey: 'useDatasetIdInput',
+            },
+        ];
+    }
+    async process(inputs, context) {
+        const { datasetProvider } = context;
+        if (datasetProvider == null) {
+            throw new Error('datasetProvider is required');
+        }
+        const datasetId = coerceTypeOptional(inputs['datasetId'], 'string') || this.data.datasetId;
+        const dataset = await datasetProvider.getDatasetData(datasetId);
+        if (!dataset) {
+            throw new Error(`Dataset with ID ${datasetId} does not exist`);
+        }
+        return {
+            ['dataset']: {
+                type: 'object[]',
+                value: dataset.rows,
+            },
+            ['datasetId_out']: {
+                type: 'string',
+                value: datasetId,
+            },
+        };
+    }
+}
+export const loadDatasetNode = nodeDefinition(LoadDatasetNodeImpl, 'Load Dataset');