@abyss-project/console 1.0.40 → 1.0.42

package/dist/workflow-expressions/helpers.js

@@ -1,262 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValueType = exports.convertExpressionToDisplayFormat = exports.convertExpressionToSaveFormat = exports.generatePreview = exports.validateExpression = exports.tokenizeEnriched = exports.getCurrentExpressionContext = exports.parseOperations = exports.extractPaths = exports.isInsideExpression = exports.hasReferences = exports.hasExpressions = exports.buildReferenceString = exports.buildExpressionString = void 0;
-const types_1 = require("./types");
-const parser_1 = require("./parser");
-const parser_2 = require("./parser");
-const resolver_1 = require("./resolver");
-const parser_3 = require("./parser");
-function buildExpressionString(path, operations) {
-    let expr = `{{${path}`;
-    if (operations && operations.length > 0) {
-        const opsStr = operations
-            .map((op) => {
-            if (op.args.length === 0) {
-                return op.name;
-            }
-            const argsStr = op.args
-                .map((arg) => (typeof arg === 'string' ? `"${arg}"` : String(arg)))
-                .join(', ');
-            return `${op.name}(${argsStr})`;
-        })
-            .join(' | ');
-        expr += ` | ${opsStr}`;
-    }
-    expr += '}}';
-    return expr;
-}
-exports.buildExpressionString = buildExpressionString;
-function buildReferenceString(type, id) {
-    return `@${type}:${id}`;
-}
-exports.buildReferenceString = buildReferenceString;
-function hasExpressions(str) {
-    return /\{\{.+?\}\}/.test(str);
-}
-exports.hasExpressions = hasExpressions;
-function hasReferences(str) {
-    return /@\w+:[a-zA-Z0-9-_]+/.test(str);
-}
-exports.hasReferences = hasReferences;
-function isInsideExpression(text, cursorPos) {
-    const beforeCursor = text.substring(0, cursorPos);
-    const lastOpenBrace = beforeCursor.lastIndexOf('{{');
-    const lastCloseBrace = beforeCursor.lastIndexOf('}}');
-    return lastOpenBrace > lastCloseBrace && lastOpenBrace !== -1;
-}
-exports.isInsideExpression = isInsideExpression;
-function extractPaths(str) {
-    const matches = str.matchAll(/\{\{(.+?)\}\}/g);
-    return Array.from(matches, (m) => {
-        const expr = m[1].trim();
-        const [path] = expr.split('|');
-        return path.trim();
-    });
-}
-exports.extractPaths = extractPaths;
-function parseOperations(opsStr) {
-    if (!opsStr || !opsStr.trim()) {
-        return [];
-    }
-    const operations = [];
-    const parts = opsStr.split('|').map((p) => p.trim());
-    for (const part of parts) {
-        if (!part) {
-            continue;
-        }
-        const match = part.match(/^(\w+)(?:\(([^)]*)\))?$/);
-        if (match) {
-            const [, name, argsStr] = match;
-            const args = [];
-            if (argsStr) {
-                const argParts = argsStr.split(',').map((a) => a.trim());
-                for (const arg of argParts) {
-                    if (arg.startsWith('"') || arg.startsWith("'")) {
-                        args.push(arg.slice(1, -1));
-                    }
-                    else if (!isNaN(Number(arg))) {
-                        args.push(Number(arg));
-                    }
-                    else if (arg === 'true' || arg === 'false') {
-                        args.push(arg === 'true');
-                    }
-                    else {
-                        args.push(arg);
-                    }
-                }
-            }
-            operations.push({ name, args });
-        }
-    }
-    return operations;
-}
-exports.parseOperations = parseOperations;
-function getCurrentExpressionContext(text, cursorPos) {
-    if (!isInsideExpression(text, cursorPos)) {
-        return null;
-    }
-    const beforeCursor = text.substring(0, cursorPos);
-    const afterCursor = text.substring(cursorPos);
-    const start = beforeCursor.lastIndexOf('{{') + 2;
-    const endMatch = afterCursor.match(/\}\}/);
-    const end = endMatch && endMatch.index !== undefined ? cursorPos + endMatch.index : text.length;
-    const expression = text.substring(start, end);
-    const [path] = expression.split('|');
-    const expressionContent = expression.trim();
-    const cursorOffsetInExpression = cursorPos - start;
-    const contentUpToCursor = expression.substring(0, cursorOffsetInExpression);
-    const match = contentUpToCursor.match(/([a-zA-Z_][a-zA-Z0-9_]*(?:\["[^"]*"\]|\['[^']*'\]|\[[^\]]*\]|\.(?:[a-zA-Z_][a-zA-Z0-9_]*))*\.?[a-zA-Z0-9_]*)$/);
-    const currentPath = match && match[1] ? match[1] : '';
-    return {
-        isInExpression: true,
-        expressionStart: start,
-        expressionContent,
-        cursorOffsetInExpression,
-        currentPath,
-        expression: expression.trim(),
-        start,
-        end,
-        path: path.trim(),
-    };
-}
-exports.getCurrentExpressionContext = getCurrentExpressionContext;
-function tokenizeEnriched(template) {
-    const backendTokens = (0, parser_1.tokenizeTemplate)(template);
-    const result = [];
-    let currentPos = 0;
-    for (const token of backendTokens) {
-        if (token.type === 'text') {
-            result.push({
-                type: 'text',
-                value: token.value,
-                rawValue: token.value,
-                start: currentPos,
-                end: currentPos + token.value.length,
-            });
-            currentPos += token.value.length;
-        }
-        else {
-            const exprValue = token.value.trim();
-            const parsed = (0, parser_2.parseExpression)(exprValue);
-            const source = (0, parser_3.detectDataSource)(exprValue);
-            const rawValue = `{{${token.value}}}`;
-            result.push({
-                type: parsed.isValid ? 'expression' : 'error',
-                value: exprValue,
-                rawValue: rawValue,
-                start: currentPos,
-                end: currentPos + rawValue.length,
-                parsed,
-                source,
-                isSecret: source === types_1.DataSourceType.SECRETS,
-            });
-            currentPos += rawValue.length;
-        }
-    }
-    return result;
-}
-exports.tokenizeEnriched = tokenizeEnriched;
-function validateExpression(expression, context) {
-    const tokens = tokenizeEnriched(expression);
-    try {
-        const parsed = (0, parser_2.parseExpression)(expression);
-        if (!parsed.isValid) {
-            return {
-                isValid: false,
-                errors: [
-                    {
-                        type: 'error',
-                        message: parsed.error || 'Invalid expression',
-                        start: 0,
-                        end: expression.length,
-                        path: expression,
-                    },
-                ],
-                warnings: [],
-                tokens,
-            };
-        }
-        (0, resolver_1.evaluateExpression)(parsed, context);
-        return {
-            isValid: true,
-            errors: [],
-            warnings: [],
-            tokens,
-        };
-    }
-    catch (error) {
-        return {
-            isValid: false,
-            errors: [
-                {
-                    type: 'error',
-                    message: error instanceof Error ? error.message : 'Validation error',
-                    start: 0,
-                    end: expression.length,
-                    path: expression,
-                },
-            ],
-            warnings: [],
-            tokens,
-        };
-    }
-}
-exports.validateExpression = validateExpression;
-function generatePreview(expression, context) {
-    try {
-        const parsed = (0, parser_2.parseExpression)(expression);
-        if (!parsed.isValid) {
-            return { value: null, type: 'error', error: parsed.error };
-        }
-        const value = (0, resolver_1.evaluateExpression)(parsed, context);
-        const type = value === null ? 'null' : typeof value;
-        return { value, type };
-    }
-    catch (error) {
-        return {
-            value: null,
-            type: 'error',
-            error: error instanceof Error ? error.message : 'Evaluation error',
-        };
-    }
-}
-exports.generatePreview = generatePreview;
-function convertExpressionToSaveFormat(expression, mappings) {
-    if (!expression || mappings.length === 0) {
-        return expression;
-    }
-    let result = expression;
-    const sortedMappings = [...mappings].sort((a, b) => b.displayPath.length - a.displayPath.length);
-    for (const mapping of sortedMappings) {
-        const regex = new RegExp(mapping.displayPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
-        result = result.replace(regex, mapping.savePath);
-    }
-    return result;
-}
-exports.convertExpressionToSaveFormat = convertExpressionToSaveFormat;
-function convertExpressionToDisplayFormat(expression, mappings) {
-    if (!expression || mappings.length === 0) {
-        return expression;
-    }
-    let result = expression;
-    const sortedMappings = [...mappings].sort((a, b) => b.savePath.length - a.savePath.length);
-    for (const mapping of sortedMappings) {
-        const regex = new RegExp(mapping.savePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
-        result = result.replace(regex, mapping.displayPath);
-    }
-    return result;
-}
-exports.convertExpressionToDisplayFormat = convertExpressionToDisplayFormat;
-function getValueType(value) {
-    if (value === null) {
-        return 'null';
-    }
-    if (value === undefined) {
-        return 'undefined';
-    }
-    if (Array.isArray(value)) {
-        return 'array';
-    }
-    return typeof value;
-}
-exports.getValueType = getValueType;

package/dist/workflow-expressions/parser.d.ts

@@ -1,8 +0,0 @@
-import type { ParsedExpression, DataSourceType } from './types';
-export declare function detectDataSource(path: string): DataSourceType | null;
-export declare function parsePathSegments(path: string): string[];
-export declare function parseExpression(expression: string): ParsedExpression;
-export declare function tokenizeTemplate(template: string): Array<{
-    type: 'text' | 'expression';
-    value: string;
-}>;