@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,206 @@
+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 { coerceType } from '../../utils/coerceType.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import {} from '../../index.js';
+import { entries, values } from '../../utils/typeSafety.js';
+export class LoopControllerNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'loopController',
+            title: 'Loop Controller',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                maxIterations: 100,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions(connections, nodes) {
+        const inputs = [];
+        const messageCount = this.#getInputPortCount(connections);
+        inputs.push({
+            dataType: 'any',
+            id: 'continue',
+            title: 'Continue',
+        });
+        let i = 1;
+        for (; i <= messageCount + 1; i++) {
+            const input = {
+                dataType: 'any',
+                id: `input${i}`,
+                title: `Input ${i}`,
+            };
+            const inputConnection = connections.find((connection) => connection.inputId === input.id && connection.inputNodeId === this.id);
+            if (inputConnection && nodes[inputConnection.outputNodeId]) {
+                input.title = nodes[inputConnection.outputNodeId].title;
+            }
+            const inputDefault = {
+                dataType: 'any',
+                id: `input${i}Default`,
+                title: `Input ${i} Default`,
+            };
+            const inputDefaultConnection = connections.find((connection) => connection.inputId === inputDefault.id && connection.inputNodeId === this.id);
+            if (inputDefaultConnection && nodes[inputDefaultConnection.outputNodeId]) {
+                inputDefault.title = `${nodes[inputDefaultConnection.outputNodeId].title} (Default)`;
+            }
+            inputs.push(input);
+            inputs.push(inputDefault);
+        }
+        return inputs;
+    }
+    getOutputDefinitions(connections, nodes) {
+        const messageCount = this.#getInputPortCount(connections);
+        const outputs = [];
+        outputs.push({
+            dataType: 'any',
+            id: 'break',
+            title: 'Break',
+        });
+        outputs.push({
+            dataType: 'number',
+            id: 'iteration',
+            title: 'Iteration',
+        });
+        for (let i = 1; i <= messageCount; i++) {
+            const output = {
+                dataType: 'any',
+                id: `output${i}`,
+                title: `Output ${i}`,
+            };
+            const inputConnection = connections.find((connection) => connection.inputId === `input${i}` && connection.inputNodeId === this.id);
+            if (inputConnection && nodes[inputConnection.outputNodeId]) {
+                output.title = `${nodes[inputConnection.outputNodeId].title}?`;
+            }
+            outputs.push(output);
+        }
+        return outputs;
+    }
+    getEditors() {
+        return [
+            {
+                type: 'number',
+                label: 'Max Iterations',
+                dataKey: 'maxIterations',
+            },
+            {
+                type: 'dropdown',
+                options: [
+                    {
+                        label: 'Break',
+                        value: 'break',
+                    },
+                    {
+                        label: 'Error',
+                        value: 'error',
+                    },
+                ],
+                label: 'At Max Iterations',
+                dataKey: 'atMaxIterationsAction',
+                defaultValue: 'error',
+                helperMessage: 'What should happen when the max iterations is reached?',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Defines the entry point for a loop. Values from inside the loop should be passed back through the "Input" ports, and their corresponding "Default" values can be specified on the input ports as well.
+
+        If the "continue" input is falsey, then the "break" output will run.
+      `,
+            infoBoxTitle: 'Loop Controller Node',
+            contextMenuTitle: 'Loop Controller',
+            group: ['Logic'],
+        };
+    }
+    #getInputPortCount(connections) {
+        const inputNodeId = this.chartNode.id;
+        const messageConnections = connections.filter((connection) => connection.inputNodeId === inputNodeId && connection.inputId.startsWith('input'));
+        let maxMessageNumber = 0;
+        for (const connection of messageConnections) {
+            const messageNumber = parseInt(connection.inputId.replace('input', ''));
+            if (messageNumber > maxMessageNumber) {
+                maxMessageNumber = messageNumber;
+            }
+        }
+        return maxMessageNumber;
+    }
+    async process(inputs, context) {
+        const output = {};
+        let inputCount = 0;
+        while (inputs[`input${inputCount + 1}`] || inputs[`input${inputCount + 1}Default`]) {
+            inputCount++;
+        }
+        const defaultInputs = entries(inputs).filter(([key]) => key.endsWith('Default'));
+        // If any of the default inputs are control-flow-excluded, then exclude all outputs.
+        // Technically, it should be "any node outside of the cycle" but this should be good enough?
+        if (defaultInputs.some(([, value]) => value?.type === 'control-flow-excluded')) {
+            for (let i = 0; i <= inputCount; i++) {
+                output[`output${i}`] = { type: 'control-flow-excluded', value: undefined };
+            }
+            output['break'] = { type: 'control-flow-excluded', value: undefined };
+            return output;
+        }
+        const iterationCount = context.attachedData.loopInfo?.iterationCount ?? 0;
+        output['iteration'] = { type: 'number', value: iterationCount + 1 };
+        if (iterationCount >= (this.data.maxIterations ?? 100) && this.data.atMaxIterationsAction !== 'break') {
+            throw new Error(`Loop controller exceeded max iterations of ${this.data.maxIterations ?? 100}`);
+        }
+        // If the continue port is not connected (so undefined), or if it's undefined before it's
+        // inside the loop itself (connection has not ran yet), then we should continue by default.
+        let continueValue = false;
+        if (inputs['continue'] === undefined) {
+            continueValue = true;
+        }
+        else {
+            const continueDataValue = inputs['continue'];
+            if (continueDataValue.type === 'control-flow-excluded') {
+                continueValue = false;
+            }
+            else {
+                continueValue = coerceType(continueDataValue, 'boolean');
+            }
+        }
+        if (iterationCount >= (this.data.maxIterations ?? 100) && this.data.atMaxIterationsAction === 'break') {
+            continueValue = false;
+        }
+        if (continueValue) {
+            output['break'] = { type: 'control-flow-excluded', value: 'loop-not-broken' };
+        }
+        else {
+            const inputValues = [];
+            for (let i = 1; i <= inputCount; i++) {
+                inputValues.push(inputs[`input${i}`]?.value);
+            }
+            // Break gets an array of all the input values
+            output['break'] = { type: 'any[]', value: inputValues };
+        }
+        for (let i = 1; i <= inputCount; i++) {
+            if (continueValue) {
+                const inputId = `input${i}`;
+                const outputId = `output${i}`;
+                if (inputs[inputId]) {
+                    output[outputId] = inputs[inputId];
+                }
+                else {
+                    output[outputId] = inputs[`${inputId}Default`];
+                }
+            }
+            else {
+                output[`output${i}`] = { type: 'control-flow-excluded', value: undefined };
+            }
+        }
+        return output;
+    }
+}
+export const loopControllerNode = nodeDefinition(LoopControllerNodeImpl, 'Loop Controller');

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

@@ -0,0 +1,137 @@
+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 {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { coerceType } from '../../utils/coerceType.js';
+export class MatchNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'match',
+            title: 'Match',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 250,
+            },
+            data: {
+                cases: ['YES', 'NO'],
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                id: 'input',
+                title: 'Test',
+                dataType: 'string',
+                required: true,
+                description: 'The value that will be tested against each of the cases.',
+            },
+            {
+                id: 'value',
+                title: 'Value',
+                dataType: 'any',
+                description: 'The value passed through to the output port that matches. If unconnected, the test value will be passed through.',
+            },
+        ];
+        return inputs;
+    }
+    getOutputDefinitions() {
+        const outputs = [];
+        for (let i = 0; i < this.data.cases.length; i++) {
+            outputs.push({
+                id: `case${i + 1}`,
+                title: this.data.cases[i]?.trim() ? this.data.cases[i] : `Case ${i + 1}`,
+                dataType: 'string',
+                description: `The 'value' (or 'test' if value is unconnected) passed through if the test value matches this regex: /${this
+                    .data.cases[i]}/`,
+            });
+        }
+        outputs.push({
+            id: 'unmatched',
+            title: 'Unmatched',
+            dataType: 'string',
+            description: 'The value (or test if value is unconnected) passed through if no regexes match.',
+        });
+        return outputs;
+    }
+    getBody() {
+        return dedent `
+      ${this.data.exclusive ? 'First Matching Case' : 'All Matching Cases'}
+      ${this.data.cases.length} Cases
+    `;
+    }
+    getEditors() {
+        return [
+            {
+                type: 'toggle',
+                dataKey: 'exclusive',
+                label: 'Exclusive',
+                helperMessage: 'If enabled, only the first matching branch will be ran.',
+            },
+            {
+                type: 'stringList',
+                dataKey: 'cases',
+                label: 'Cases',
+                placeholder: 'Case (regular expression)',
+                helperMessage: '(Regular expressions)',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Any number of regular expressions can be configured, each corresponding to an output of the node. The output port of the first matching regex will be ran, and all other output ports will not be ran.
+      `,
+            infoBoxTitle: 'Match Node',
+            contextMenuTitle: 'Match',
+            group: ['Logic'],
+        };
+    }
+    async process(inputs) {
+        const inputString = coerceType(inputs['input'], 'string');
+        const value = inputs['value'];
+        const outputType = value === undefined ? 'string' : value.type;
+        const outputValue = value === undefined ? inputString : value.value;
+        const cases = this.data.cases;
+        let matched = false;
+        const output = {};
+        for (let i = 0; i < cases.length; i++) {
+            const regExp = new RegExp(cases[i]);
+            const match = regExp.test(inputString);
+            const canMatch = !this.data.exclusive || !matched;
+            if (match && canMatch) {
+                matched = true;
+                output[`case${i + 1}`] = {
+                    type: outputType,
+                    value: outputValue,
+                };
+            }
+            else {
+                output[`case${i + 1}`] = {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                };
+            }
+        }
+        if (!matched) {
+            output['unmatched'] = {
+                type: outputType,
+                value: outputValue,
+            };
+        }
+        else {
+            output['unmatched'] = {
+                type: 'control-flow-excluded',
+                value: undefined,
+            };
+        }
+        return output;
+    }
+}
+export const matchNode = nodeDefinition(MatchNodeImpl, 'Match');

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

@@ -0,0 +1,86 @@
+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 { dedent } from 'ts-dedent';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+export class NumberNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'number',
+            title: 'Number',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                value: 0,
+                round: false,
+                roundTo: 0,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return this.data.useValueInput
+            ? [
+                {
+                    dataType: 'any',
+                    id: 'input',
+                    title: 'Input',
+                },
+            ]
+            : [];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'number',
+                id: 'value',
+                title: 'Value',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            { type: 'number', label: 'Value', dataKey: 'value', useInputToggleDataKey: 'useValueInput' },
+            { type: 'toggle', label: 'Round', dataKey: 'round' },
+            { type: 'number', label: 'Round To', dataKey: 'roundTo' },
+        ];
+    }
+    getBody() {
+        return this.data.useValueInput ? `(Input to number)` : (this.data.value ?? 0).toLocaleString();
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Outputs a number constant, or converts an input value into a number.
+
+        Can be configured to round the number to a certain number of decimal places.
+      `,
+            infoBoxTitle: 'Number Node',
+            contextMenuTitle: 'Number',
+            group: ['Numbers'],
+        };
+    }
+    async process(inputs) {
+        let value = this.data.useValueInput
+            ? coerceTypeOptional(inputs['input'], 'number') ?? this.data.value ?? 0
+            : this.data.value ?? 0;
+        const { roundTo = 0, round = false } = this.data;
+        if (round) {
+            value = Math.round(value * Math.pow(10, roundTo)) / Math.pow(10, roundTo);
+        }
+        return {
+            ['value']: {
+                type: 'number',
+                value,
+            },
+        };
+    }
+}
+export const numberNode = nodeDefinition(NumberNodeImpl, 'Number');

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

@@ -0,0 +1,121 @@
+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 { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+const DEFAULT_JSON_TEMPLATE = `{
+  "key": "{{input}}"
+}`;
+export class ObjectNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'object',
+            title: 'Object',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                jsonTemplate: DEFAULT_JSON_TEMPLATE,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions(connections) {
+        // Extract inputs from text, everything like {{input}}
+        const inputNames = [...new Set(this.chartNode.data.jsonTemplate.match(/\{\{([^}]+)\}\}/g))];
+        return (inputNames?.map((inputName) => {
+            return {
+                // id and title should not have the {{ and }}
+                id: inputName.slice(2, -2),
+                title: inputName.slice(2, -2),
+                dataType: 'any',
+                required: false,
+            };
+        }) ?? []);
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: ['object', 'object[]'],
+                id: 'output',
+                title: 'Output',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'custom',
+                customEditorId: 'ObjectNodeAiAssist',
+                label: 'AI Assist',
+            },
+            {
+                type: 'code',
+                label: 'JSON Template',
+                dataKey: 'jsonTemplate',
+                language: 'json',
+                theme: 'prompt-interpolation',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Creates an object from input values and a JSON template, escaping the input values and inserting them into the template.
+
+        Use double-quotes around the input values to escape them. String values are automatically escaped.
+
+        Useful for creating objects from multiple inputs.
+      `,
+            infoBoxTitle: 'Object Node',
+            contextMenuTitle: 'Object',
+            group: ['Objects'],
+        };
+    }
+    interpolate(baseString, values) {
+        return baseString.replace(/("?)\{\{([^}]+)\}\}("?)/g, (_m, openQuote, key, _closeQuote) => {
+            const isQuoted = Boolean(openQuote);
+            const value = values[key];
+            if (value == null) {
+                return 'null';
+            }
+            if (isQuoted && typeof value === 'string') {
+                // Adds double-quotes back.
+                return JSON.stringify(value);
+            }
+            if (isQuoted) {
+                // Non-strings require a double-stringify, first to turn them into a string, then to escape that string and add quotes.
+                return JSON.stringify(JSON.stringify(value));
+            }
+            // Otherwise, it was not quoted, so no need to double-stringify
+            return JSON.stringify(value);
+        });
+    }
+    async process(inputs) {
+        const inputMap = Object.keys(inputs).reduce((acc, key) => {
+            acc[key] = inputs[key]?.value;
+            return acc;
+        }, {});
+        const outputValue = JSON.parse(this.interpolate(this.chartNode.data.jsonTemplate, inputMap));
+        if (Array.isArray(outputValue)) {
+            return {
+                output: {
+                    type: 'object[]',
+                    value: outputValue,
+                },
+            };
+        }
+        return {
+            output: {
+                type: 'object',
+                value: outputValue,
+            },
+        };
+    }
+}
+export const objectNode = nodeDefinition(ObjectNodeImpl, 'Object');

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

@@ -0,0 +1,78 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../GraphProcessor.js';
+import { dedent } from 'ts-dedent';
+export class PassthroughNodeImpl extends NodeImpl {
+    static create = () => {
+        const chartNode = {
+            type: 'passthrough',
+            title: 'Passthrough',
+            id: nanoid(),
+            data: {},
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 175,
+            },
+        };
+        return chartNode;
+    };
+    getInputDefinitions(connections) {
+        const inputs = [];
+        const inputCount = this.#getInputPortCount(connections);
+        for (let i = 1; i <= inputCount; i++) {
+            inputs.push({
+                dataType: 'any',
+                id: `input${i}`,
+                title: `Input ${i}`,
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions(connections) {
+        const outputs = [];
+        const inputCount = this.#getInputPortCount(connections);
+        for (let i = 1; i <= inputCount - 1; i++) {
+            outputs.push({
+                dataType: 'any',
+                id: `output${i}`,
+                title: `Output ${i}`,
+            });
+        }
+        return outputs;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Simply passes the input value to the output without any modifications.
+      `,
+            infoBoxTitle: 'Passthrough Node',
+            contextMenuTitle: 'Passthrough',
+            group: ['Logic'],
+        };
+    }
+    #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;
+    }
+    async process(inputData) {
+        const inputCount = Object.keys(inputData).filter((key) => key.startsWith('input')).length;
+        const outputs = {};
+        for (let i = 1; i <= inputCount; i++) {
+            const input = inputData[`input${i}`];
+            outputs[`output${i}`] = input;
+        }
+        return outputs;
+    }
+}
+export const passthroughNode = nodeDefinition(PassthroughNodeImpl, 'Passthrough');

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

@@ -0,0 +1,61 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../../index.js';
+import { expectType } from '../../utils/index.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+export class PlayAudioNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'playAudio',
+            title: 'Play Audio',
+            visualData: { x: 0, y: 0, width: 200 },
+            data: {},
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        inputDefinitions.push({
+            id: 'data',
+            title: 'Data',
+            dataType: 'audio',
+            coerced: false,
+        });
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'data',
+                title: 'Audio Data',
+                dataType: 'audio',
+            },
+        ];
+    }
+    getEditors() {
+        return [];
+    }
+    static getUIData() {
+        return {
+            contextMenuTitle: 'Play Audio',
+            group: 'Input/Output',
+            infoBoxTitle: 'Play Audio Node',
+            infoBoxBody: 'Plays audio data to the speakers.',
+        };
+    }
+    async process(inputData, context) {
+        if (!context.audioProvider) {
+            throw new Error('Playing audio is not supported in this context');
+        }
+        const data = expectType(inputData['data'], 'audio');
+        await context.audioProvider.playAudio({ type: 'audio', value: data }, context.signal);
+        return {
+            ['data']: {
+                type: 'audio',
+                value: data,
+            },
+        };
+    }
+}
+export const playAudioNode = nodeDefinition(PlayAudioNodeImpl, 'Play Audio');