@alpic80/rivet-core 1.19.1-aidon.1

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

@@ -0,0 +1,165 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../GraphProcessor.js';
+import {} from '../../index.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import { expectType } from '../../utils/expectType.js';
+export class ReadDirectoryNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'readDirectory',
+            title: 'Read Directory',
+            visualData: { x: 0, y: 0 },
+            data: {
+                path: 'examples',
+                recursive: false,
+                usePathInput: false,
+                useRecursiveInput: false,
+                includeDirectories: false,
+                useIncludeDirectoriesInput: false,
+                filterGlobs: [],
+                useFilterGlobsInput: false,
+                relative: false,
+                useRelativeInput: false,
+                ignores: [],
+                useIgnoresInput: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.usePathInput) {
+            inputDefinitions.push({
+                id: 'path',
+                title: 'Path',
+                dataType: 'string',
+                required: true,
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useRecursiveInput) {
+            inputDefinitions.push({
+                id: 'recursive',
+                title: 'Recursive',
+                dataType: 'boolean',
+                required: true,
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useIncludeDirectoriesInput) {
+            inputDefinitions.push({
+                id: 'includeDirectories',
+                title: 'Include Directories',
+                dataType: 'boolean',
+                required: true,
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useFilterGlobsInput) {
+            inputDefinitions.push({
+                id: 'filterGlobs',
+                title: 'Filter Globs',
+                dataType: 'string[]',
+                required: true,
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useRelativeInput) {
+            inputDefinitions.push({
+                id: 'relative',
+                title: 'Relative',
+                dataType: 'boolean',
+                required: true,
+                coerced: false,
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'rootPath',
+                title: 'Root Path',
+                dataType: 'string',
+            },
+            {
+                id: 'paths',
+                title: 'Paths',
+                dataType: 'string[]',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      Path: ${this.data.usePathInput ? '(Input)' : this.data.path}
+      Recursive: ${this.data.useRecursiveInput ? '(Input)' : this.data.recursive}
+      Include Directories: ${this.data.useIncludeDirectoriesInput ? '(Input)' : this.data.includeDirectories}
+      Relative: ${this.data.useRelativeInput ? '(Input)' : this.data.relative}
+      Filters: ${this.data.useFilterGlobsInput
+            ? '(Input)'
+            : this.data.filterGlobs.length > 0
+                ? this.data.filterGlobs.join(', ')
+                : 'None'}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Reads the contents of the specified directory and outputs an array of filenames.
+      `,
+            infoBoxTitle: 'Read Directory Node',
+            contextMenuTitle: 'Read Directory',
+            group: ['Input/Output'],
+        };
+    }
+    async process(inputData, context) {
+        const { nativeApi } = context;
+        if (nativeApi == null) {
+            throw new Error('This node requires a native API to run.');
+        }
+        const path = this.chartNode.data.usePathInput
+            ? expectType(inputData['path'], 'string')
+            : this.chartNode.data.path;
+        const recursive = this.chartNode.data.useRecursiveInput
+            ? expectType(inputData['recursive'], 'boolean')
+            : this.chartNode.data.recursive;
+        const includeDirectories = this.chartNode.data.useIncludeDirectoriesInput
+            ? expectType(inputData['includeDirectories'], 'boolean')
+            : this.chartNode.data.includeDirectories;
+        const filterGlobs = this.chartNode.data.useFilterGlobsInput
+            ? expectType(inputData['filterGlobs'], 'string[]')
+            : this.chartNode.data.filterGlobs;
+        const relative = this.chartNode.data.useRelativeInput
+            ? expectType(inputData['relative'], 'boolean')
+            : this.chartNode.data.relative;
+        const ignores = this.chartNode.data.useIgnoresInput
+            ? expectType(inputData['ignores'], 'string[]')
+            : this.chartNode.data.ignores;
+        try {
+            const files = await nativeApi.readdir(path, undefined, {
+                recursive,
+                includeDirectories,
+                filterGlobs,
+                relative,
+                ignores,
+            });
+            const outputs = {
+                ['paths']: { type: 'string[]', value: files },
+                ['rootPath']: { type: 'string', value: path },
+            };
+            return outputs;
+        }
+        catch (err) {
+            const outputs = {
+                ['paths']: { type: 'string[]', value: ['(no such path)'] },
+                ['rootPath']: { type: 'string', value: path },
+            };
+            return outputs;
+        }
+    }
+}
+export const readDirectoryNode = nodeDefinition(ReadDirectoryNodeImpl, 'Read Directory');

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

@@ -0,0 +1,114 @@
+import {} from '../NodeBase.js';
+import {} from '../DataValue.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { nanoid } from 'nanoid/non-secure';
+import { getInputOrData } from '../../utils/index.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+export class ReadFileNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'readFile',
+            title: 'Read File',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                path: '',
+                asBinary: false,
+                usePathInput: true,
+                errorOnMissingFile: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.usePathInput) {
+            inputDefinitions.push({
+                id: 'path',
+                title: 'Path',
+                dataType: 'string',
+                coerced: false,
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'content',
+                title: 'Content',
+                dataType: this.data.asBinary ? 'binary' : 'string',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Reads the contents of the specified file and outputs it as a string.
+      `,
+            infoBoxTitle: 'Read File Node',
+            contextMenuTitle: 'Read File',
+            group: ['Input/Output'],
+        };
+    }
+    getEditors() {
+        return [
+            {
+                type: 'filePathBrowser',
+                label: 'Path',
+                dataKey: 'path',
+                useInputToggleDataKey: 'usePathInput',
+            },
+            {
+                type: 'toggle',
+                label: 'Error on Missing File',
+                dataKey: 'errorOnMissingFile',
+            },
+            {
+                type: 'toggle',
+                label: 'Read as Binary',
+                dataKey: 'asBinary',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      ${this.data.asBinary ? 'Read as Binary' : 'Read as Text'}
+      ${this.data.usePathInput ? '' : `Path: ${this.data.path}`}
+    `;
+    }
+    async process(inputData, context) {
+        const { nativeApi } = context;
+        if (nativeApi == null) {
+            throw new Error('This node requires a native API to run.');
+        }
+        const path = getInputOrData(this.chartNode.data, inputData, 'path');
+        try {
+            if (this.data.asBinary) {
+                const content = await nativeApi.readBinaryFile(path);
+                const buffer = await content.arrayBuffer();
+                return {
+                    ['content']: { type: 'binary', value: new Uint8Array(buffer) },
+                };
+            }
+            else {
+                const content = await nativeApi.readTextFile(path, undefined);
+                return {
+                    ['content']: { type: 'string', value: content },
+                };
+            }
+        }
+        catch (err) {
+            if (this.chartNode.data.errorOnMissingFile) {
+                throw err;
+            }
+            else {
+                return {
+                    ['content']: { type: 'control-flow-excluded', value: undefined },
+                };
+            }
+        }
+    }
+}
+export const readFileNode = nodeDefinition(ReadFileNodeImpl, 'Read File');

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

@@ -0,0 +1,118 @@
+import { NodeImpl } from '../NodeImpl.js';
+import { nanoid } from 'nanoid/non-secure';
+import { dedent } from 'ts-dedent';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { getInputOrData, coerceType, newId, inferType } from '../../utils/index.js';
+import { arrayizeDataValue, unwrapDataValue } from '../DataValue.js';
+export class ReplaceDatasetNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'replaceDataset',
+            title: 'Replace Dataset',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                datasetId: '',
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        inputDefinitions.push({
+            id: 'data',
+            dataType: 'object[]',
+            title: 'Data',
+            description: 'The new data of the dataset. If empty, the dataset will be cleared. May be an array of array of strings, or an array of DatasetRow objects with { id, data } properties. If a string[][], IDs will be generated.',
+        });
+        if (this.data.useDatasetIdInput) {
+            inputDefinitions.push({
+                id: 'datasetId',
+                title: 'Dataset ID',
+                dataType: 'string',
+                description: 'The ID of the dataset to replace.',
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'dataset',
+                title: 'Dataset',
+                dataType: 'object[]',
+                description: 'The new data of the dataset. An array of DatasetRow objects with { id, data } properties.',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Replaces the data in a dataset with the given data. If no data is given, the dataset will be cleared instead.
+      `,
+            infoBoxTitle: 'Replace Dataset Node',
+            contextMenuTitle: 'Replace 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 = getInputOrData(this.data, inputs, 'datasetId', 'string');
+        const dataInput = inputs['data'];
+        if (!dataInput) {
+            await datasetProvider.putDatasetData(datasetId, { id: datasetId, rows: [] });
+            return {
+                ['dataset']: {
+                    type: 'object[]',
+                    value: [],
+                },
+            };
+        }
+        let dataArrays = unwrapDataValue(dataInput).value;
+        if (!Array.isArray(dataArrays)) {
+            throw new Error('Data input must be either an array of rows, or an array of columns for a single row.');
+        }
+        const isDatasetRow = (row) => {
+            return typeof row === 'object' && row != null && 'id' in row && 'data' in row;
+        };
+        const firstElem = dataArrays[0];
+        if (!Array.isArray(firstElem) && !isDatasetRow(firstElem)) {
+            dataArrays = [dataArrays];
+        }
+        const rows = dataArrays.map((row) => {
+            if (Array.isArray(row)) {
+                return {
+                    id: newId(),
+                    data: row.map((value) => coerceType(inferType(value), 'string')),
+                };
+            }
+            if ('id' in row && 'data' in row) {
+                return row;
+            }
+            throw new Error('Data input must be an array of strings or DatasetRows');
+        });
+        await datasetProvider.putDatasetData(datasetId, {
+            id: datasetId,
+            rows,
+        });
+        return {
+            ['dataset']: {
+                type: 'object[]',
+                value: rows,
+            },
+        };
+    }
+}
+export const replaceDatasetNode = nodeDefinition(ReplaceDatasetNodeImpl, 'Replace Dataset');

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

@@ -0,0 +1,124 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { isArrayDataType, isScalarDataType, scalarDefaults, unwrapDataValue, } from '../DataValue.js';
+import {} from '../GraphProcessor.js';
+import { coerceType } from '../../utils/coerceType.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import {} from '../NodeBodySpec.js';
+export class SetGlobalNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'setGlobal',
+            title: 'Set Global',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                id: 'variable-name',
+                dataType: 'string',
+                useIdInput: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                id: 'value',
+                title: 'Value',
+                dataType: this.chartNode.data.dataType,
+            },
+        ];
+        if (this.data.useIdInput) {
+            inputs.push({
+                id: 'id',
+                title: 'Variable ID',
+                dataType: 'string',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'saved-value',
+                title: 'Value',
+                dataType: this.data.dataType,
+            },
+            {
+                id: 'previous-value',
+                title: 'Previous Value',
+                dataType: this.data.dataType,
+            },
+            {
+                id: 'variable_id_out',
+                title: 'Variable ID',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                dataKey: 'id',
+                useInputToggleDataKey: 'useIdInput',
+                label: 'ID',
+            },
+            {
+                type: 'dataTypeSelector',
+                dataKey: 'dataType',
+                label: 'Data Type',
+                useInputToggleDataKey: 'useIdInput',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      ${this.data.id}
+      Type: ${this.data.dataType}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Sets a global value that is shared across all graphs and subgraphs. The id of the global value and the value itself are configured in this node.
+      `,
+            infoBoxTitle: 'Set Global Node',
+            contextMenuTitle: 'Set Global',
+            group: ['Advanced'],
+        };
+    }
+    async process(inputs, context) {
+        const rawValue = inputs['value'];
+        if (!rawValue) {
+            return {};
+        }
+        const id = this.data.useIdInput ? coerceType(inputs['id'], 'string') : this.data.id;
+        if (!id) {
+            throw new Error('Missing variable ID');
+        }
+        let previousValue = context.getGlobal(this.data.id);
+        if (!previousValue && isArrayDataType(this.data.dataType)) {
+            previousValue = { type: this.data.dataType, value: [] };
+        }
+        else if (!previousValue && isScalarDataType(this.data.dataType)) {
+            previousValue = { type: this.data.dataType, value: scalarDefaults[this.data.dataType] };
+        }
+        const value = unwrapDataValue(rawValue);
+        context.setGlobal(id, value);
+        return {
+            ['saved-value']: value,
+            ['previous-value']: previousValue,
+            ['variable_id_out']: { type: 'string', value: id },
+        };
+    }
+}
+export const setGlobalNode = nodeDefinition(SetGlobalNodeImpl, 'Set Global');

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

@@ -0,0 +1,64 @@
+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 { shuffle } from 'lodash-es';
+import { isArrayDataValue } from '../DataValue.js';
+import { dedent } from 'ts-dedent';
+export class ShuffleNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'shuffle',
+            title: 'Shuffle',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 175,
+            },
+            data: {},
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                dataType: 'any[]',
+                id: 'array',
+                title: 'Array',
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'any[]',
+                id: 'shuffled',
+                title: 'Shuffled',
+            },
+        ];
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Shuffles the input array. Outputs the shuffled array.
+      `,
+            infoBoxTitle: 'Shuffle Node',
+            contextMenuTitle: 'Shuffle',
+            group: ['Lists'],
+        };
+    }
+    async process(inputs) {
+        const input = inputs['array'];
+        const items = input ? (isArrayDataValue(input) ? input.value : [input.value]) : [];
+        const shuffled = shuffle(items);
+        return {
+            ['shuffled']: {
+                type: inputs['array']?.type ?? 'any[]',
+                value: shuffled,
+            },
+        };
+    }
+}
+export const shuffleNode = nodeDefinition(ShuffleNodeImpl, 'Shuffle');

package/dist/esm/model/nodes/SliceNode.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 {} from '../GraphProcessor.js';
+import { entries } from '../../utils/typeSafety.js';
+import { dedent } from 'ts-dedent';
+import {} from '../EditorDefinition.js';
+import {} from '../../index.js';
+import { coerceType } from '../../utils/coerceType.js';
+import { getInputOrData } from '../../utils/index.js';
+export class SliceNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'slice',
+            title: 'Slice',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                start: 0,
+                count: undefined,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        const inputs = [
+            {
+                dataType: 'any[]',
+                id: 'input',
+                title: 'Input',
+            },
+        ];
+        if (this.data.useStartInput) {
+            inputs.push({
+                dataType: 'number',
+                id: 'start',
+                title: 'Start',
+            });
+        }
+        if (this.data.useCountInput) {
+            inputs.push({
+                dataType: 'number',
+                id: 'count',
+                title: 'Count',
+            });
+        }
+        return inputs;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                dataType: 'any[]',
+                id: 'output',
+                title: 'Output',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            { type: 'number', label: 'Start', dataKey: 'start', useInputToggleDataKey: 'useStartInput', allowEmpty: true },
+            { type: 'number', label: 'Count', dataKey: 'count', useInputToggleDataKey: 'useCountInput', allowEmpty: true },
+        ];
+    }
+    getBody() {
+        return dedent `
+      Start: ${this.data.useStartInput ? '(Using Input)' : this.data.start == null ? '0' : this.data.start}
+      Count: ${this.data.useCountInput ? '(Using Input)' : this.data.count == null ? 'All' : this.data.count}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Slices an array from the start index for the count number of elements.
+
+        Useful for extracting a portion of an array.
+      `,
+            infoBoxTitle: 'Slice Node',
+            contextMenuTitle: 'Slice',
+            group: ['Lists'],
+        };
+    }
+    async process(inputs) {
+        const inputArray = coerceType(inputs['input'], 'any[]');
+        const start = getInputOrData(this.data, inputs, 'start', 'number') ?? 0;
+        const count = getInputOrData(this.data, inputs, 'count', 'number') ?? inputArray.length;
+        const outputArray = inputArray.slice(start, start + count);
+        return {
+            ['output']: {
+                type: 'any[]',
+                value: outputArray,
+            },
+        };
+    }
+}
+export const sliceNode = nodeDefinition(SliceNodeImpl, 'Slice');