blockmine 1.19.1 → 1.21.0

package/backend/src/core/nodes/flow_for_each.js

@@ -0,0 +1,39 @@
+const BreakLoopSignal = require('../BreakLoopSignal');
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ * @param {Map} helpers.memo - Карта для мемоизации значений в рамках одного выполнения графа.
+ * @param {function} helpers.clearLoopBodyMemo - Функция для очистки мемоизации внутри тела цикла.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, memo, clearLoopBodyMemo } = helpers;
+
+    const array = await resolvePinValue(node, 'array', []);
+    if (Array.isArray(array)) {
+        try {
+            for (let i = 0; i < array.length; i++) {
+                const element = array[i];
+                memo.set(`${node.id}:element`, element);
+                memo.set(`${node.id}:index`, i);
+                clearLoopBodyMemo(node);
+                await traverse(node, 'loop_body');
+            }
+        } catch (e) {
+            if (e instanceof BreakLoopSignal) {
+                // Цикл был прерван узлом Break, это ожидаемое поведение.
+            } else {
+                // Перебрасываем другие, неожиданные ошибки.
+                throw e;
+            }
+        }
+    }
+    await traverse(node, 'completed');
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/flow_sequence.js

@@ -0,0 +1,16 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const pinCount = node.data?.pinCount || 2;
+    for (let i = 0; i < pinCount; i++) {
+        await helpers.traverse(node, `exec_${i}`);
+    }
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/flow_switch.js

@@ -0,0 +1,47 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    const value = await resolvePinValue(node, 'value');
+    const caseCount = node.data?.caseCount || 0;
+    let matched = false;
+    
+    for (let i = 0; i < caseCount; i++) {
+        const caseValue = node.data?.[`case_${i}`];
+        if (caseValue !== undefined) {
+            let isMatch = false;
+            
+            if (Array.isArray(value) && Array.isArray(caseValue)) {
+                isMatch = JSON.stringify(value) === JSON.stringify(caseValue);
+            } else if (typeof value === 'object' && typeof caseValue === 'object' && value !== null && caseValue !== null) {
+                isMatch = JSON.stringify(value) === JSON.stringify(caseValue);
+            } else if (typeof value === 'number' && typeof caseValue === 'number') {
+                isMatch = value === caseValue;
+            } else if (typeof value === 'boolean' && typeof caseValue === 'boolean') {
+                isMatch = value === caseValue;
+            } else {
+                isMatch = String(value) === String(caseValue);
+            }
+            
+            if (isMatch) {
+                await traverse(node, `case_${i}`);
+                matched = true;
+                break;
+            }
+        }
+    }
+    
+    if (!matched) {
+        await traverse(node, 'default');
+    }
+}
+
+module.exports = {
+    execute,
+};

package/backend/src/core/nodes/flow_while.js

@@ -0,0 +1,64 @@
+const BreakLoopSignal = require('../BreakLoopSignal');
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ * @param {function} helpers.clearLoopBodyMemo - Функция для очистки мемоизации тела цикла.
+ * @param {Map} helpers.memo - Map для хранения мемоизированных значений.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse, clearLoopBodyMemo, memo } = helpers;
+
+    let iteration = 0;
+    const maxIterations = 1000;
+
+    try {
+        while (iteration < maxIterations) {
+            const condition = await resolvePinValue(node, 'condition', false);
+            if (!condition) break;
+
+            memo.set(`${node.id}:iteration`, iteration);
+            clearLoopBodyMemo(node);
+            await traverse(node, 'loop_body');
+            iteration++;
+        }
+
+        if (iteration >= maxIterations) {
+            console.warn(`[GraphExecutionEngine] Цикл while достиг максимального количества итераций (${maxIterations})`);
+        }
+    } catch (e) {
+        if (e instanceof BreakLoopSignal) {
+            // Прерывание цикла - это нормально
+        } else {
+            throw e;
+        }
+    }
+
+    await traverse(node, 'completed');
+}
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {Map} helpers.memo - Map для хранения мемоизированных значений.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { memo } = helpers;
+
+    if (pinId === 'iteration') {
+        return memo.get(`${node.id}:iteration`);
+    }
+
+    return null;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

package/backend/src/core/nodes/logic_compare.js

@@ -0,0 +1,33 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const op = node.data?.operation || '==';
+        const valA = await resolvePinValue(node, 'a');
+        const valB = await resolvePinValue(node, 'b');
+
+        switch (op) {
+            case '==': return valA == valB;
+            case '!=': return valA != valB;
+            case '>': return valA > valB;
+            case '<': return valA < valB;
+            case '>=': return valA >= valB;
+            case '<=': return valA <= valB;
+            default: return false;
+        }
+    }
+
+    return false;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/logic_operation.js

@@ -0,0 +1,35 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const op = node.data?.operation || 'AND';
+        const inputs = [];
+        const pinCount = node.data?.pinCount || 2;
+
+        for (let i = 0; i < pinCount; i++) {
+            const value = await resolvePinValue(node, `pin_${i}`, false);
+            inputs.push(value);
+        }
+
+        switch (op) {
+            case 'AND': return inputs.every(Boolean);
+            case 'OR': return inputs.some(Boolean);
+            case 'NOT': return !inputs[0];
+            default: return false;
+        }
+    }
+
+    return false;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/math_operation.js

@@ -0,0 +1,31 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const op = node.data?.operation || '+';
+        const a = Number(await resolvePinValue(node, 'a', 0));
+        const b = Number(await resolvePinValue(node, 'b', 0));
+
+        switch (op) {
+            case '+': return a + b;
+            case '-': return a - b;
+            case '*': return a * b;
+            case '/': return b !== 0 ? a / b : 0;
+            default: return 0;
+        }
+    }
+
+    return 0;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/math_random_number.js

@@ -0,0 +1,43 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const minRaw = await resolvePinValue(node, 'min', node.data.min ?? '0');
+        const maxRaw = await resolvePinValue(node, 'max', node.data.max ?? '1');
+
+        const minStr = String(minRaw);
+        const maxStr = String(maxRaw);
+
+        const min = parseFloat(minStr.replace(',', '.'));
+        const max = parseFloat(maxStr.replace(',', '.'));
+
+        if (isNaN(min) || isNaN(max)) {
+            return NaN;
+        }
+
+        const produceFloat = minStr.includes('.') || minStr.includes(',') || !Number.isInteger(min) ||
+                            maxStr.includes('.') || maxStr.includes(',') || !Number.isInteger(max);
+
+        if (produceFloat) {
+            return Math.random() * (max - min) + min;
+        } else {
+            const minInt = Math.ceil(min);
+            const maxInt = Math.floor(max);
+            return Math.floor(Math.random() * (maxInt - minInt + 1)) + minInt;
+        }
+    }
+
+    return 0;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/object_create.js

@@ -0,0 +1,40 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'object') {
+        if (node.data?.advanced) {
+            try {
+                return JSON.parse(node.data.jsonValue || '{}');
+            } catch (e) {
+                console.error('Ошибка парсинга JSON в object:create:', e);
+                return {};
+            }
+        } else {
+            const numPins = node.data?.pinCount || 0;
+            const obj = {};
+
+            for (let i = 0; i < numPins; i++) {
+                const key = node.data[`key_${i}`];
+                if (key) {
+                    obj[key] = await resolvePinValue(node, `value_${i}`);
+                }
+            }
+
+            return obj;
+        }
+    }
+
+    return {};
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/object_delete.js

@@ -0,0 +1,26 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'new_object') {
+        const obj = await resolvePinValue(node, 'object', {});
+        const key = await resolvePinValue(node, 'key', '');
+
+        const newObj = { ...obj };
+        delete newObj[key];
+        return newObj;
+    }
+
+    return {};
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/object_get.js

@@ -0,0 +1,23 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers, defaultValue = null) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'value') {
+        const obj = await resolvePinValue(node, 'object', {});
+        const key = await resolvePinValue(node, 'key', '');
+        return obj[key] ?? defaultValue;
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/object_has_key.js

@@ -0,0 +1,30 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {Map} helpers.memo - Map для хранения мемоизированных значений.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue, memo } = helpers;
+
+    const obj = await resolvePinValue(node, 'object', {});
+    const key = await resolvePinValue(node, 'key', '');
+    const exists = obj.hasOwnProperty(key);
+
+    memo.set(`${node.id}:value`, exists ? obj[key] : null);
+
+    if (pinId === 'result') {
+        return exists;
+    } else if (pinId === 'value') {
+        return memo.get(`${node.id}:value`);
+    }
+
+    return null;
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/object_set.js

@@ -0,0 +1,27 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'new_object') {
+        const obj = await resolvePinValue(node, 'object', {});
+        const key = await resolvePinValue(node, 'key', '');
+        const val = await resolvePinValue(node, 'value');
+
+        const newObj = { ...obj };
+        newObj[key] = val;
+        return newObj;
+    }
+
+    return {};
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/string_concat.js

@@ -0,0 +1,27 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const pinCount = node.data?.pinCount || 2;
+        let finalString = '';
+        for (let i = 0; i < pinCount; i++) {
+            const part = await resolvePinValue(node, `pin_${i}`, '');
+            finalString += String(part ?? '');
+        }
+        return finalString;
+    }
+
+    return '';
+}
+
+module.exports = {
+    evaluate,
+};

package/backend/src/core/nodes/string_contains.js

@@ -0,0 +1,41 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { traverse } = helpers;
+    await traverse(node, 'exec');
+}
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const haystack = String(await resolvePinValue(node, 'haystack', ''));
+        const needle = String(await resolvePinValue(node, 'needle', ''));
+        const caseSensitive = await resolvePinValue(node, 'case_sensitive', false);
+
+        if (caseSensitive) {
+            return haystack.includes(needle);
+        } else {
+            return haystack.toLowerCase().includes(needle.toLowerCase());
+        }
+    }
+
+    return null;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

package/backend/src/core/nodes/string_ends_with.js

@@ -0,0 +1,43 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    await traverse(node, 'exec');
+}
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const str = String(await resolvePinValue(node, 'string', ''));
+        const suffix = String(await resolvePinValue(node, 'suffix', ''));
+        const caseSensitive = await resolvePinValue(node, 'case_sensitive', false);
+
+        if (caseSensitive) {
+            return str.endsWith(suffix);
+        } else {
+            return str.toLowerCase().endsWith(suffix.toLowerCase());
+        }
+    }
+
+    return null;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

package/backend/src/core/nodes/string_equals.js

@@ -0,0 +1,36 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { traverse } = helpers;
+    await traverse(node, 'exec');
+}
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'result') {
+        const strA = String(await resolvePinValue(node, 'a', ''));
+        const strB = String(await resolvePinValue(node, 'b', ''));
+        const caseSensitive = node.data?.case_sensitive ?? true;
+        return caseSensitive ? strA === strB : strA.toLowerCase() === strB.toLowerCase();
+    }
+
+    return null;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};

package/backend/src/core/nodes/string_length.js

@@ -0,0 +1,36 @@
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @param {function} helpers.traverse - Функция для перехода к следующему узлу.
+ */
+async function execute(node, context, helpers) {
+    const { resolvePinValue, traverse } = helpers;
+
+    await traverse(node, 'exec');
+}
+
+/**
+ * @param {object} node - Экземпляр узла из графа.
+ * @param {string} pinId - Идентификатор выходного пина, значение которого нужно вычислить.
+ * @param {object} context - Контекст выполнения графа.
+ * @param {object} helpers - Вспомогательные функции движка.
+ * @param {function} helpers.resolvePinValue - Функция для получения значения с входного пина.
+ * @returns {Promise<any>} - Вычисленное значение для выходного пина.
+ */
+async function evaluate(node, pinId, context, helpers) {
+    const { resolvePinValue } = helpers;
+
+    if (pinId === 'length') {
+        const str = String(await resolvePinValue(node, 'string', ''));
+        return str.length;
+    }
+
+    return 0;
+}
+
+module.exports = {
+    execute,
+    evaluate,
+};