@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,141 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../GraphProcessor.js';
+import {} from '../../index.js';
+import { match } from 'ts-pattern';
+import { dedent } from 'ts-dedent';
+import { coerceType, coerceTypeOptional } from '../../utils/coerceType.js';
+const unaryOperation = ['abs', 'negate'];
+const isUnaryOp = (operation) => unaryOperation.includes(operation);
+export class EvaluateNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'evaluate',
+            title: 'Evaluate',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 175,
+            },
+            data: {
+                operation: '+',
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                dataType: 'number',
+                id: 'a',
+                title: 'A',
+            },
+        ];
+        const isUnary = !this.data.useOperationInput && isUnaryOp(this.data.operation);
+        if (!isUnary) {
+            inputs.push({
+                dataType: 'number',
+                id: 'b',
+                title: 'B',
+            });
+        }
+        if (this.data.useOperationInput) {
+            inputs.push({
+                dataType: 'string',
+                id: 'operation',
+                title: 'Operation',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'number',
+                id: 'output',
+                title: 'Output',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'dropdown',
+                label: 'Operation',
+                dataKey: 'operation',
+                options: [
+                    { label: '+', value: '+' },
+                    { label: '-', value: '-' },
+                    { label: '*', value: '*' },
+                    { label: '/', value: '/' },
+                    { label: '^', value: '^' },
+                    { label: '%', value: '%' },
+                    { label: 'abs', value: 'abs' },
+                    { label: 'negate', value: 'negate' },
+                ],
+                useInputToggleDataKey: 'useOperationInput',
+            },
+        ];
+    }
+    getBody() {
+        const isUnary = !this.data.useOperationInput && isUnaryOp(this.data.operation);
+        if (isUnary) {
+            return match(this.data.operation)
+                .with('abs', () => 'abs(A)')
+                .with('negate', () => '-A')
+                .exhaustive();
+        }
+        if (this.data.operation === '^') {
+            return '!markdownA<sup>B</sup>';
+        }
+        return this.data.useOperationInput ? 'A (Operation) B' : `A ${this.data.operation} B`;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Evaluates the configured mathematical operation on the input values and outputs the result.
+
+        For more complex operations, you should use the \`Code\` node.
+      `,
+            infoBoxTitle: 'Evaluate Node',
+            contextMenuTitle: 'Evaluate',
+            group: ['Numbers'],
+        };
+    }
+    async process(inputs) {
+        const operation = (this.data.useOperationInput ? coerceType(inputs['operation'], 'string') : this.data.operation);
+        const inputA = coerceTypeOptional(inputs['a'], 'number');
+        const inputB = coerceTypeOptional(inputs['b'], 'number');
+        if (isUnaryOp(operation) && inputA) {
+            return {
+                ['output']: {
+                    type: 'number',
+                    value: match(operation)
+                        .with('abs', () => Math.abs(inputA))
+                        .with('negate', () => -inputA)
+                        .exhaustive(),
+                },
+            };
+        }
+        if (inputA == null || inputB == null) {
+            throw new Error('Missing input');
+        }
+        return {
+            ['output']: {
+                type: 'number',
+                value: match(operation)
+                    .with('+', () => inputA + inputB)
+                    .with('-', () => inputA - inputB)
+                    .with('*', () => inputA * inputB)
+                    .with('/', () => inputA / inputB)
+                    .with('^', () => Math.pow(inputA, inputB))
+                    .with('%', () => inputA % inputB)
+                    .exhaustive(),
+            },
+        };
+    }
+}
+export const evaluateNode = nodeDefinition(EvaluateNodeImpl, 'Evaluate');

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

@@ -0,0 +1,162 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../DataValue.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../GraphProcessor.js';
+import { coerceType } from '../../utils/coerceType.js';
+import { getError } from '../../utils/errors.js';
+import {} from '../ProcessContext.js';
+import { omit } from 'lodash-es';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import {} from '../NodeBodySpec.js';
+export class ExternalCallNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'externalCall',
+            title: 'External Call',
+            visualData: { x: 0, y: 0, width: 150 },
+            data: {
+                functionName: '',
+                useFunctionNameInput: false,
+                useErrorOutput: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.useFunctionNameInput) {
+            inputDefinitions.push({
+                id: 'functionName',
+                title: 'Function Name',
+                dataType: 'string',
+            });
+        }
+        inputDefinitions.push({
+            id: 'arguments',
+            title: 'Arguments',
+            dataType: 'any[]',
+        });
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        const outputs = [
+            {
+                id: 'result',
+                title: 'Result',
+                dataType: 'any',
+            },
+        ];
+        if (this.chartNode.data.useErrorOutput) {
+            outputs.push({
+                id: 'error',
+                title: 'Error',
+                dataType: 'string',
+            });
+        }
+        return outputs;
+    }
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Function Name',
+                dataKey: 'functionName',
+                useInputToggleDataKey: 'useFunctionNameInput',
+            },
+            {
+                type: 'toggle',
+                label: 'Use Error Output',
+                dataKey: 'useErrorOutput',
+            },
+        ];
+    }
+    getBody() {
+        return this.data.useFunctionNameInput ? '(Using Input)' : this.data.functionName;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Provides a way to call into the host project from inside a Rivet graph when Rivet graphs are integrated into another project.
+      `,
+            infoBoxTitle: 'External Call Node',
+            contextMenuTitle: 'External Call',
+            group: ['Advanced'],
+        };
+    }
+    async process(inputs, context) {
+        const functionName = this.chartNode.data.useFunctionNameInput
+            ? coerceType(inputs['functionName'], 'string')
+            : this.chartNode.data.functionName;
+        const args = inputs['arguments'];
+        let arrayArgs = {
+            type: 'any[]',
+            value: [],
+        };
+        if (args) {
+            if (args.type.endsWith('[]') === false) {
+                arrayArgs = {
+                    type: 'any[]',
+                    value: [args.value],
+                };
+            }
+            else {
+                arrayArgs = args;
+            }
+        }
+        const fn = context.externalFunctions[functionName];
+        const externalContext = omit(context, ['setGlobal']);
+        if (!fn) {
+            if (this.data.useErrorOutput) {
+                return {
+                    ['result']: {
+                        type: 'control-flow-excluded',
+                        value: undefined,
+                    },
+                    ['error']: {
+                        type: 'string',
+                        value: `Function ${functionName} not was not defined using setExternalCall`,
+                    },
+                };
+            }
+            else {
+                throw new Error(`Function ${functionName} not was not defined using setExternalCall`);
+            }
+        }
+        if (this.data.useErrorOutput) {
+            try {
+                const result = await fn(externalContext, ...arrayArgs.value);
+                return {
+                    ['result']: result,
+                    ['cost']: {
+                        type: 'number',
+                        value: result.cost ?? 0,
+                    },
+                    ['error']: {
+                        type: 'control-flow-excluded',
+                        value: undefined,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    ['result']: {
+                        type: 'control-flow-excluded',
+                        value: undefined,
+                    },
+                    ['error']: {
+                        type: 'string',
+                        value: getError(error).message,
+                    },
+                };
+            }
+        }
+        const result = await fn(externalContext, ...arrayArgs.value);
+        return {
+            ['result']: result,
+        };
+    }
+}
+export const externalCallNode = nodeDefinition(ExternalCallNodeImpl, 'External Call');

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

@@ -0,0 +1,122 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../DataValue.js';
+import { expectType } from '../../utils/index.js';
+import { dedent } from 'ts-dedent';
+export class ExtractJsonNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'extractJson',
+            title: 'Extract JSON',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {},
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'input',
+                title: 'Input',
+                dataType: 'string',
+                required: true,
+                coerced: false,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'output',
+                title: 'Output',
+                dataType: 'object',
+            },
+            {
+                id: 'noMatch',
+                title: 'No Match',
+                dataType: 'string',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Finds and parses the first JSON object in the input text.
+
+        Outputs the parsed object.
+      `,
+            infoBoxTitle: 'Extract JSON Node',
+            contextMenuTitle: 'Extract JSON',
+            group: ['Objects'],
+        };
+    }
+    async process(inputs) {
+        const inputString = expectType(inputs['input'], 'string');
+        try {
+            const parsed = JSON.parse(inputString);
+            return {
+                ['output']: {
+                    type: 'object',
+                    value: parsed,
+                },
+                ['noMatch']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        catch (_err) {
+            // Fall back to more manual parsing
+        }
+        // Find the first { or [ and the last } or ], and try parsing everything in between including them.
+        let firstBracket = inputString.indexOf('{');
+        let lastBracket = inputString.lastIndexOf('}');
+        let firstSquareBracket = inputString.indexOf('[');
+        let lastSquareBracket = inputString.lastIndexOf(']');
+        const firstIndex = firstBracket >= 0 && firstSquareBracket >= 0
+            ? Math.min(firstBracket, firstSquareBracket)
+            : firstBracket >= 0
+                ? firstBracket
+                : firstSquareBracket;
+        const lastIndex = lastBracket >= 0 && lastSquareBracket >= 0
+            ? Math.max(lastBracket, lastSquareBracket)
+            : lastBracket >= 0
+                ? lastBracket
+                : lastSquareBracket;
+        const substring = inputString.substring(firstIndex, lastIndex + 1);
+        let jsonObject = undefined;
+        try {
+            jsonObject = JSON.parse(substring);
+        }
+        catch (err) {
+            return {
+                ['noMatch']: {
+                    type: 'string',
+                    value: inputString,
+                },
+                ['output']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            };
+        }
+        return {
+            ['output']: {
+                type: 'object',
+                value: jsonObject,
+            },
+            ['noMatch']: {
+                type: 'control-flow-excluded',
+                value: undefined,
+            },
+        };
+    }
+}
+export const extractJsonNode = nodeDefinition(ExtractJsonNodeImpl, 'Extract JSON');

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

@@ -0,0 +1,100 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { expectType } from '../../utils/expectType.js';
+import { dedent } from 'ts-dedent';
+export class ExtractMarkdownCodeBlocksNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'extractMarkdownCodeBlocks',
+            title: 'Extract Markdown Code Blocks',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {},
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'input',
+                title: 'Input',
+                dataType: 'string',
+                required: true,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'firstBlock',
+                title: 'First Block',
+                dataType: 'string',
+            },
+            {
+                id: 'allBlocks',
+                title: 'All Blocks',
+                dataType: 'string[]',
+            },
+            {
+                id: 'languages',
+                title: 'Languages',
+                dataType: 'string[]',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Extracts the code blocks in the input Markdown text.
+
+        Outputs the first matched block, all matched blocks, and the languages specified for the blocks.
+      `,
+            infoBoxTitle: 'Extract Markdown Code Blocks Node',
+            contextMenuTitle: 'Extract Markdown Code Blocks',
+            group: ['Text'],
+        };
+    }
+    async process(inputs) {
+        const inputString = expectType(inputs['input'], 'string');
+        const regex = /```(\w*)\n([\s\S]*?)```/g;
+        let match;
+        let firstBlock;
+        const allBlocks = [];
+        const languages = [];
+        while ((match = regex.exec(inputString)) !== null) {
+            const language = match[1];
+            const block = match[2];
+            if (!firstBlock) {
+                firstBlock = block;
+            }
+            allBlocks.push(block);
+            languages.push(language);
+        }
+        return {
+            ['firstBlock']: firstBlock == null
+                ? {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                }
+                : {
+                    type: 'string',
+                    value: firstBlock,
+                },
+            ['allBlocks']: {
+                type: 'string[]',
+                value: allBlocks,
+            },
+            ['languages']: {
+                type: 'string[]',
+                value: languages,
+            },
+        };
+    }
+}
+export const extractMarkdownCodeBlocksNode = nodeDefinition(ExtractMarkdownCodeBlocksNodeImpl, 'Extract Markdown Code Blocks');

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

@@ -0,0 +1,128 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../DataValue.js';
+import { JSONPath } from 'jsonpath-plus';
+import { expectType } from '../../utils/expectType.js';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+export class ExtractObjectPathNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'extractObjectPath',
+            title: 'Extract Object Path',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                path: '$',
+                usePathInput: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [
+            {
+                id: 'object',
+                title: 'Object',
+                dataType: 'object',
+                required: true,
+            },
+        ];
+        if (this.chartNode.data.usePathInput) {
+            inputDefinitions.push({
+                id: 'path',
+                title: 'Path',
+                dataType: 'string',
+                required: true,
+                coerced: false,
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'match',
+                title: 'Match',
+                dataType: 'any',
+            },
+            {
+                id: 'all_matches',
+                title: 'All Matches',
+                dataType: 'any[]',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'code',
+                label: 'Path',
+                dataKey: 'path',
+                language: 'jsonpath',
+                useInputToggleDataKey: 'usePathInput',
+            },
+        ];
+    }
+    getBody() {
+        return this.data.usePathInput ? '(Using Input)' : this.data.path;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Extracts the value at the specified path from the input value. The path uses JSONPath notation to navigate through the value.
+      `,
+            infoBoxTitle: 'Extract Object Path Node',
+            contextMenuTitle: 'Extract Object Path',
+            group: ['Objects'],
+        };
+    }
+    async process(inputs) {
+        const inputObject = coerceTypeOptional(inputs['object'], 'object');
+        const inputPath = this.chartNode.data.usePathInput
+            ? expectType(inputs['path'], 'string')
+            : this.chartNode.data.path;
+        if (!inputPath) {
+            throw new Error('Path input is not provided');
+        }
+        let matches;
+        try {
+            // Wrap doesn't seem to wrap when the input is undefined or null...
+            const match = JSONPath({ json: inputObject ?? null, path: inputPath.trim(), wrap: true });
+            matches = match == null ? [] : match;
+        }
+        catch (err) {
+            matches = [];
+        }
+        if (matches.length === 0) {
+            return {
+                ['match']: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+                ['all_matches']: {
+                    type: 'any[]',
+                    value: [],
+                },
+            };
+        }
+        return {
+            ['match']: {
+                type: 'any',
+                value: matches[0],
+            },
+            ['all_matches']: {
+                type: 'any[]',
+                value: matches,
+            },
+        };
+    }
+}
+export const extractObjectPathNode = nodeDefinition(ExtractObjectPathNodeImpl, 'Extract Object Path');