@abyss-project/main 1.0.93 → 1.0.95

package/dist/expressions/index.d.ts

@@ -0,0 +1,5 @@
+export type { ResourceMapping, ExpressionToken, ExpressionParserConfig, ParsedExpression, ExpressionMappingOptions, } from './types';
+export { parseExpression, stringifyExpression, } from './parser';
+export { convertToDisplayFormat, convertToSaveFormat, extractMappings, validateExpression, createResourceMapping, } from './mapper';
+export type { ExpressionContext, ResolverOptions, } from './resolver';
+export { resolveExpression, isDynamicExpression, extractPaths, } from './resolver';

package/dist/expressions/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPaths = exports.isDynamicExpression = exports.resolveExpression = exports.createResourceMapping = exports.validateExpression = exports.extractMappings = exports.convertToSaveFormat = exports.convertToDisplayFormat = exports.stringifyExpression = exports.parseExpression = void 0;
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "parseExpression", { enumerable: true, get: function () { return parser_1.parseExpression; } });
+Object.defineProperty(exports, "stringifyExpression", { enumerable: true, get: function () { return parser_1.stringifyExpression; } });
+var mapper_1 = require("./mapper");
+Object.defineProperty(exports, "convertToDisplayFormat", { enumerable: true, get: function () { return mapper_1.convertToDisplayFormat; } });
+Object.defineProperty(exports, "convertToSaveFormat", { enumerable: true, get: function () { return mapper_1.convertToSaveFormat; } });
+Object.defineProperty(exports, "extractMappings", { enumerable: true, get: function () { return mapper_1.extractMappings; } });
+Object.defineProperty(exports, "validateExpression", { enumerable: true, get: function () { return mapper_1.validateExpression; } });
+Object.defineProperty(exports, "createResourceMapping", { enumerable: true, get: function () { return mapper_1.createResourceMapping; } });
+var resolver_1 = require("./resolver");
+Object.defineProperty(exports, "resolveExpression", { enumerable: true, get: function () { return resolver_1.resolveExpression; } });
+Object.defineProperty(exports, "isDynamicExpression", { enumerable: true, get: function () { return resolver_1.isDynamicExpression; } });
+Object.defineProperty(exports, "extractPaths", { enumerable: true, get: function () { return resolver_1.extractPaths; } });

package/dist/expressions/mapper.d.ts

@@ -0,0 +1,9 @@
+import type { ResourceMapping, ExpressionMappingOptions } from './types';
+export declare function convertToDisplayFormat<TSource = string>(expression: string, mappings: ResourceMapping<TSource>[], options?: ExpressionMappingOptions): string;
+export declare function convertToSaveFormat<TSource = string>(expression: string, mappings: ResourceMapping<TSource>[], options?: ExpressionMappingOptions): string;
+export declare function extractMappings<TSource = string>(expression: string, mappings: ResourceMapping<TSource>[]): ResourceMapping<TSource>[];
+export declare function validateExpression<TSource = string>(expression: string, mappings: ResourceMapping<TSource>[]): {
+    valid: boolean;
+    missingReferences: string[];
+};
+export declare function createResourceMapping<TSource = string>(source: TSource, resourceId: string, resourceName: string, pathBuilder: (source: TSource, identifier: string) => string): ResourceMapping<TSource>;

package/dist/expressions/mapper.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResourceMapping = exports.validateExpression = exports.extractMappings = exports.convertToSaveFormat = exports.convertToDisplayFormat = void 0;
+const parser_1 = require("./parser");
+function convertToDisplayFormat(expression, mappings, options = {}) {
+    const opts = {
+        strict: false,
+        preserveUnknown: true,
+        ...options,
+    };
+    if (!expression) {
+        return expression;
+    }
+    let result = expression;
+    const sortedMappings = [...mappings].sort((a, b) => b.savePath.length - a.savePath.length);
+    for (const mapping of sortedMappings) {
+        const escapedSavePath = escapeRegExp(mapping.savePath);
+        const regex = new RegExp(escapedSavePath, 'g');
+        result = result.replace(regex, mapping.displayPath);
+    }
+    return result;
+}
+exports.convertToDisplayFormat = convertToDisplayFormat;
+function convertToSaveFormat(expression, mappings, options = {}) {
+    const opts = {
+        strict: false,
+        preserveUnknown: true,
+        ...options,
+    };
+    if (!expression) {
+        return expression;
+    }
+    let result = expression;
+    const sortedMappings = [...mappings].sort((a, b) => b.displayPath.length - a.displayPath.length);
+    for (const mapping of sortedMappings) {
+        const escapedDisplayPath = escapeRegExp(mapping.displayPath);
+        const regex = new RegExp(escapedDisplayPath, 'g');
+        result = result.replace(regex, mapping.savePath);
+    }
+    return result;
+}
+exports.convertToSaveFormat = convertToSaveFormat;
+function extractMappings(expression, mappings) {
+    if (!expression) {
+        return [];
+    }
+    const parsed = (0, parser_1.parseExpression)(expression);
+    const usedMappings = [];
+    for (const reference of parsed.references) {
+        const mapping = mappings.find((m) => m.displayPath.includes(reference.source) ||
+            m.savePath.includes(reference.source));
+        if (mapping && !usedMappings.includes(mapping)) {
+            usedMappings.push(mapping);
+        }
+    }
+    return usedMappings;
+}
+exports.extractMappings = extractMappings;
+function validateExpression(expression, mappings) {
+    if (!expression) {
+        return { valid: true, missingReferences: [] };
+    }
+    const parsed = (0, parser_1.parseExpression)(expression);
+    const missingReferences = [];
+    for (const reference of parsed.references) {
+        const hasMapping = mappings.some((m) => m.displayPath.includes(reference.source) ||
+            m.savePath.includes(reference.source));
+        if (!hasMapping) {
+            missingReferences.push(`${reference.source}.${reference.path}`);
+        }
+    }
+    return {
+        valid: missingReferences.length === 0,
+        missingReferences,
+    };
+}
+exports.validateExpression = validateExpression;
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function createResourceMapping(source, resourceId, resourceName, pathBuilder) {
+    return {
+        source,
+        resourceId,
+        resourceName,
+        displayPath: pathBuilder(source, resourceName),
+        savePath: pathBuilder(source, resourceId),
+    };
+}
+exports.createResourceMapping = createResourceMapping;

package/dist/expressions/parser.d.ts

@@ -0,0 +1,3 @@
+import type { ExpressionToken, ExpressionParserConfig, ParsedExpression } from './types';
+export declare function parseExpression(expression: string, config?: ExpressionParserConfig): ParsedExpression;
+export declare function stringifyExpression(tokens: ExpressionToken[], config?: ExpressionParserConfig): string;

package/dist/expressions/parser.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyExpression = exports.parseExpression = void 0;
+const DEFAULT_CONFIG = {
+    openDelimiter: '{{',
+    closeDelimiter: '}}',
+    trimExpressions: true,
+};
+function parseExpression(expression, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const tokens = [];
+    const references = [];
+    let currentPosition = 0;
+    let isDynamic = false;
+    while (currentPosition < expression.length) {
+        const openIndex = expression.indexOf(cfg.openDelimiter, currentPosition);
+        if (openIndex === -1) {
+            const remaining = expression.slice(currentPosition);
+            if (remaining) {
+                tokens.push({ type: 'text', value: remaining });
+            }
+            break;
+        }
+        if (openIndex > currentPosition) {
+            tokens.push({
+                type: 'text',
+                value: expression.slice(currentPosition, openIndex),
+            });
+        }
+        const closeIndex = expression.indexOf(cfg.closeDelimiter, openIndex + cfg.openDelimiter.length);
+        if (closeIndex === -1) {
+            tokens.push({
+                type: 'text',
+                value: expression.slice(openIndex),
+            });
+            break;
+        }
+        const rawExpression = expression.slice(openIndex, closeIndex + cfg.closeDelimiter.length);
+        let expressionContent = expression.slice(openIndex + cfg.openDelimiter.length, closeIndex);
+        if (cfg.trimExpressions) {
+            expressionContent = expressionContent.trim();
+        }
+        const referenceMatch = parseReference(expressionContent);
+        if (referenceMatch) {
+            references.push(referenceMatch);
+        }
+        tokens.push({
+            type: 'expression',
+            value: expressionContent,
+            raw: rawExpression,
+        });
+        isDynamic = true;
+        currentPosition = closeIndex + cfg.closeDelimiter.length;
+    }
+    return {
+        tokens,
+        isDynamic,
+        references,
+    };
+}
+exports.parseExpression = parseExpression;
+function parseReference(expression) {
+    expression = expression.trim();
+    const dotMatch = expression.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\.(.+)$/);
+    if (dotMatch) {
+        return {
+            source: dotMatch[1],
+            path: dotMatch[2],
+        };
+    }
+    const bracketMatch = expression.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\[['"](.+?)['"]\]$/);
+    if (bracketMatch) {
+        return {
+            source: bracketMatch[1],
+            path: bracketMatch[2],
+        };
+    }
+    return null;
+}
+function stringifyExpression(tokens, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    return tokens
+        .map((token) => {
+        if (token.type === 'text') {
+            return token.value;
+        }
+        if (token.type === 'expression') {
+            return token.raw || `${cfg.openDelimiter}${token.value}${cfg.closeDelimiter}`;
+        }
+        if (token.type === 'reference') {
+            return `${cfg.openDelimiter}${token.source}.${token.path}${cfg.closeDelimiter}`;
+        }
+        return '';
+    })
+        .join('');
+}
+exports.stringifyExpression = stringifyExpression;

package/dist/expressions/resolver.d.ts

@@ -0,0 +1,12 @@
+export interface ExpressionContext {
+    [key: string]: unknown;
+}
+export interface ResolverOptions {
+    strict?: boolean;
+    functions?: Record<string, (...args: unknown[]) => unknown>;
+    allowNested?: boolean;
+    maxDepth?: number;
+}
+export declare function resolveExpression(expression: string, context: ExpressionContext, options?: ResolverOptions): unknown;
+export declare function isDynamicExpression(expression: string): boolean;
+export declare function extractPaths(expression: string): string[];

package/dist/expressions/resolver.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPaths = exports.isDynamicExpression = exports.resolveExpression = void 0;
+const parser_1 = require("./parser");
+function resolveExpression(expression, context, options = {}) {
+    const opts = {
+        strict: false,
+        functions: {},
+        allowNested: true,
+        maxDepth: 10,
+        ...options,
+    };
+    if (!expression) {
+        return expression;
+    }
+    const parsed = (0, parser_1.parseExpression)(expression);
+    if (!parsed.isDynamic) {
+        return expression;
+    }
+    if (parsed.tokens.length === 1 && parsed.tokens[0].type === 'expression') {
+        return evaluateExpression(parsed.tokens[0].value, context, opts);
+    }
+    return parsed.tokens
+        .map((token) => {
+        if (token.type === 'text') {
+            return token.value;
+        }
+        if (token.type === 'expression') {
+            const value = evaluateExpression(token.value, context, opts);
+            return value === undefined || value === null ? '' : String(value);
+        }
+        return '';
+    })
+        .join('');
+}
+exports.resolveExpression = resolveExpression;
+function evaluateExpression(expression, context, options) {
+    try {
+        const value = resolvePath(expression, context, options);
+        return value;
+    }
+    catch (error) {
+        if (options.strict) {
+            throw error;
+        }
+        return undefined;
+    }
+}
+function resolvePath(path, context, options, depth = 0) {
+    if (depth > options.maxDepth) {
+        throw new Error(`Maximum depth exceeded for path: ${path}`);
+    }
+    const bracketMatch = path.match(/^([^[]+)\[['"]([^'"]+)['"]\](.*)$/);
+    if (bracketMatch) {
+        const [, base, key, rest] = bracketMatch;
+        const baseValue = resolvePath(base, context, options, depth + 1);
+        if (baseValue === undefined || baseValue === null) {
+            return undefined;
+        }
+        const value = baseValue[key];
+        if (rest && rest.length > 0) {
+            return resolvePath(rest.replace(/^\./, ''), { _: value }, options, depth + 1);
+        }
+        return value;
+    }
+    const parts = path.split('.');
+    let current = context;
+    for (const part of parts) {
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function isDynamicExpression(expression) {
+    const parsed = (0, parser_1.parseExpression)(expression);
+    return parsed.isDynamic;
+}
+exports.isDynamicExpression = isDynamicExpression;
+function extractPaths(expression) {
+    const parsed = (0, parser_1.parseExpression)(expression);
+    return parsed.references.map((ref) => `${ref.source}.${ref.path}`);
+}
+exports.extractPaths = extractPaths;

package/dist/expressions/types.d.ts

@@ -0,0 +1,36 @@
+export interface ResourceMapping<TSource = string> {
+    source: TSource;
+    displayPath: string;
+    savePath: string;
+    resourceId: string;
+    resourceName: string;
+}
+export type ExpressionToken = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'expression';
+    value: string;
+    raw: string;
+} | {
+    type: 'reference';
+    source: string;
+    path: string;
+};
+export interface ExpressionParserConfig {
+    openDelimiter?: string;
+    closeDelimiter?: string;
+    trimExpressions?: boolean;
+}
+export interface ParsedExpression {
+    tokens: ExpressionToken[];
+    isDynamic: boolean;
+    references: Array<{
+        source: string;
+        path: string;
+    }>;
+}
+export interface ExpressionMappingOptions {
+    strict?: boolean;
+    preserveUnknown?: boolean;
+}

package/dist/types/enum/abyss-application-event.enum.d.ts

@@ -277,5 +277,9 @@ export declare enum AbyssApplicationEvent {
     ABYSS_CONSOLE_WORKFLOW_STEP_EXECUTION_SKIP = "abyss-console.workflow.step-execution.skip",
     ABYSS_CONSOLE_PROJECT_CREATE = "abyss-console.project.create",
     ABYSS_CONSOLE_PROJECT_DELETE = "abyss-console.project.delete",
-    ABYSS_CONSOLE_PROJECT_SYNC = "abyss-console.project.sync"
+    ABYSS_CONSOLE_PROJECT_SYNC = "abyss-console.project.sync",
+    ABYSS_CONSOLE_VARIABLE_CREATE = "abyss-console.variable.create",
+    ABYSS_CONSOLE_VARIABLE_READ_PUBLIC = "abyss-console.variable.read-public",
+    ABYSS_CONSOLE_VARIABLE_UPDATE = "abyss-console.variable.update",
+    ABYSS_CONSOLE_VARIABLE_DELETE = "abyss-console.variable.delete"
 }

package/dist/types/enum/abyss-application-event.enum.js

@@ -282,4 +282,8 @@ var AbyssApplicationEvent;
     AbyssApplicationEvent["ABYSS_CONSOLE_PROJECT_CREATE"] = "abyss-console.project.create";
     AbyssApplicationEvent["ABYSS_CONSOLE_PROJECT_DELETE"] = "abyss-console.project.delete";
     AbyssApplicationEvent["ABYSS_CONSOLE_PROJECT_SYNC"] = "abyss-console.project.sync";
+    AbyssApplicationEvent["ABYSS_CONSOLE_VARIABLE_CREATE"] = "abyss-console.variable.create";
+    AbyssApplicationEvent["ABYSS_CONSOLE_VARIABLE_READ_PUBLIC"] = "abyss-console.variable.read-public";
+    AbyssApplicationEvent["ABYSS_CONSOLE_VARIABLE_UPDATE"] = "abyss-console.variable.update";
+    AbyssApplicationEvent["ABYSS_CONSOLE_VARIABLE_DELETE"] = "abyss-console.variable.delete";
 })(AbyssApplicationEvent || (exports.AbyssApplicationEvent = AbyssApplicationEvent = {}));

package/dist/types/enum/project-access-permission.enum.d.ts

@@ -21,5 +21,9 @@ export declare enum ProjectAccessPermission {
     WORKFLOW_UPDATE = "WORKFLOW_UPDATE",
     WORKFLOW_DELETE = "WORKFLOW_DELETE",
     WORKFLOW_EXECUTE = "WORKFLOW_EXECUTE",
-    WORKFLOW_NOTIFICATION = "WORKFLOW_NOTIFICATION"
+    WORKFLOW_NOTIFICATION = "WORKFLOW_NOTIFICATION",
+    VARIABLE_CREATE = "VARIABLE_CREATE",
+    VARIABLE_READ = "VARIABLE_READ",
+    VARIABLE_UPDATE = "VARIABLE_UPDATE",
+    VARIABLE_DELETE = "VARIABLE_DELETE"
 }

package/dist/types/enum/project-access-permission.enum.js

@@ -26,4 +26,8 @@ var ProjectAccessPermission;
     ProjectAccessPermission["WORKFLOW_DELETE"] = "WORKFLOW_DELETE";
     ProjectAccessPermission["WORKFLOW_EXECUTE"] = "WORKFLOW_EXECUTE";
     ProjectAccessPermission["WORKFLOW_NOTIFICATION"] = "WORKFLOW_NOTIFICATION";
+    ProjectAccessPermission["VARIABLE_CREATE"] = "VARIABLE_CREATE";
+    ProjectAccessPermission["VARIABLE_READ"] = "VARIABLE_READ";
+    ProjectAccessPermission["VARIABLE_UPDATE"] = "VARIABLE_UPDATE";
+    ProjectAccessPermission["VARIABLE_DELETE"] = "VARIABLE_DELETE";
 })(ProjectAccessPermission || (exports.ProjectAccessPermission = ProjectAccessPermission = {}));

package/dist/workflow/expression/expression-functions.utils.d.ts

@@ -0,0 +1,6 @@
+export declare function uuid(): string;
+export declare function random(min: number, max: number): number;
+export declare function now(): number;
+export declare function isoDate(): string;
+export declare const PIPE_OPERATIONS: Record<string, (value: unknown, ...args: unknown[]) => unknown>;
+export declare const BUILT_IN_FUNCTIONS: Record<string, (...args: unknown[]) => unknown>;

package/dist/workflow/expression/expression-functions.utils.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILT_IN_FUNCTIONS = exports.PIPE_OPERATIONS = exports.isoDate = exports.now = exports.random = exports.uuid = void 0;
+function uuid() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+exports.uuid = uuid;
+function random(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+exports.random = random;
+function now() {
+    return Date.now();
+}
+exports.now = now;
+function isoDate() {
+    return new Date().toISOString();
+}
+exports.isoDate = isoDate;
+exports.PIPE_OPERATIONS = {
+    lower: (value) => String(value).toLowerCase(),
+    upper: (value) => String(value).toUpperCase(),
+    trim: (value) => String(value).trim(),
+    length: (value) => (Array.isArray(value) ? value.length : String(value).length),
+    abs: (value) => Math.abs(Number(value)),
+    round: (value) => Math.round(Number(value)),
+    floor: (value) => Math.floor(Number(value)),
+    ceil: (value) => Math.ceil(Number(value)),
+    json: (value) => JSON.stringify(value),
+    parse: (value) => {
+        try {
+            return JSON.parse(String(value));
+        }
+        catch {
+            return value;
+        }
+    },
+    isNumber: (value) => typeof value === 'number' && !isNaN(value),
+    isString: (value) => typeof value === 'string',
+    isArray: (value) => Array.isArray(value),
+    isObject: (value) => typeof value === 'object' && value !== null,
+};
+exports.BUILT_IN_FUNCTIONS = {
+    uuid,
+    random: (...args) => random(Number(args[0]), Number(args[1])),
+    now,
+    isoDate,
+    min: (...args) => Math.min(...args.map(Number)),
+    max: (...args) => Math.max(...args.map(Number)),
+    abs: (...args) => Math.abs(Number(args[0])),
+    round: (...args) => Math.round(Number(args[0])),
+    floor: (...args) => Math.floor(Number(args[0])),
+    ceil: (...args) => Math.ceil(Number(args[0])),
+};

package/dist/workflow/expression/expression-mapper.d.ts

@@ -0,0 +1,11 @@
+import { type ExpressionMappingOptions } from '../../expressions';
+import type { WorkflowResourceMapping, DataSourceType } from './expression.types';
+export declare function convertToDisplayFormat(expression: string, mappings: WorkflowResourceMapping[], options?: ExpressionMappingOptions): string;
+export declare function convertToSaveFormat(expression: string, mappings: WorkflowResourceMapping[], options?: ExpressionMappingOptions): string;
+export declare function extractMappings(expression: string, mappings: WorkflowResourceMapping[]): WorkflowResourceMapping[];
+export declare function validateExpression(expression: string, mappings: WorkflowResourceMapping[]): {
+    valid: boolean;
+    missingReferences: string[];
+};
+export declare function createWorkflowResourceMapping(source: DataSourceType, resourceId: string, resourceName: string): WorkflowResourceMapping;
+export declare function buildPathSegment(source: DataSourceType, identifier: string): string;

package/dist/workflow/expression/expression-mapper.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPathSegment = exports.createWorkflowResourceMapping = exports.validateExpression = exports.extractMappings = exports.convertToSaveFormat = exports.convertToDisplayFormat = void 0;
+const expressions_1 = require("../../expressions");
+function convertToDisplayFormat(expression, mappings, options) {
+    return (0, expressions_1.convertToDisplayFormat)(expression, mappings, options);
+}
+exports.convertToDisplayFormat = convertToDisplayFormat;
+function convertToSaveFormat(expression, mappings, options) {
+    return (0, expressions_1.convertToSaveFormat)(expression, mappings, options);
+}
+exports.convertToSaveFormat = convertToSaveFormat;
+function extractMappings(expression, mappings) {
+    return (0, expressions_1.extractMappings)(expression, mappings);
+}
+exports.extractMappings = extractMappings;
+function validateExpression(expression, mappings) {
+    return (0, expressions_1.validateExpression)(expression, mappings);
+}
+exports.validateExpression = validateExpression;
+function createWorkflowResourceMapping(source, resourceId, resourceName) {
+    return (0, expressions_1.createResourceMapping)(source, resourceId, resourceName, buildPathSegment);
+}
+exports.createWorkflowResourceMapping = createWorkflowResourceMapping;
+function buildPathSegment(source, identifier) {
+    const escapedId = identifier.replace(/[.\[\]]/g, '\\$&');
+    if (/[\s."']/.test(identifier)) {
+        return `${source}["${identifier}"]`;
+    }
+    return `${source}.${escapedId}`;
+}
+exports.buildPathSegment = buildPathSegment;

package/dist/workflow/expression/expression-mapping.utils.d.ts

@@ -0,0 +1,4 @@
+import { ResourceMapping } from './expression.types';
+export declare function convertExpressionToSaveFormat(expression: string, mappings: ResourceMapping[]): string;
+export declare function convertExpressionToDisplayFormat(expression: string, mappings: ResourceMapping[]): string;
+export declare function extractExpressionTokens(text: string): string[];

package/dist/workflow/expression/expression-mapping.utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractExpressionTokens = exports.convertExpressionToDisplayFormat = exports.convertExpressionToSaveFormat = void 0;
+const expression_tokenizer_utils_1 = require("./expression-tokenizer.utils");
+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 displayPattern = escapeRegExp(mapping.displayPath);
+        const regex = new RegExp(displayPattern, '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 savePattern = escapeRegExp(mapping.savePath);
+        const regex = new RegExp(savePattern, 'g');
+        result = result.replace(regex, mapping.displayPath);
+    }
+    return result;
+}
+exports.convertExpressionToDisplayFormat = convertExpressionToDisplayFormat;
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function extractExpressionTokens(text) {
+    const tokens = (0, expression_tokenizer_utils_1.tokenize)(text);
+    const expressions = tokens
+        .filter((token) => token.type === 'expression')
+        .map((token) => token.value);
+    return Array.from(new Set(expressions));
+}
+exports.extractExpressionTokens = extractExpressionTokens;

package/dist/workflow/expression/expression-resolver.utils.d.ts

@@ -0,0 +1,3 @@
+export declare function resolvePathValue(path: string, context: Record<string, unknown>): unknown;
+export declare function resolveExpressions(text: string, context: Record<string, unknown>): string;
+export declare function isTruthy(value: unknown): boolean;

package/dist/workflow/expression/expression-resolver.utils.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTruthy = exports.resolveExpressions = exports.resolvePathValue = void 0;
+const expression_tokenizer_utils_1 = require("./expression-tokenizer.utils");
+function resolvePathValue(path, context) {
+    const segments = (0, expression_tokenizer_utils_1.parsePathSegments)(path);
+    let current = context;
+    for (const segment of segments) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (/^\d+$/.test(segment) && Array.isArray(current)) {
+            current = current[Number(segment)];
+        }
+        else {
+            current = current[segment];
+        }
+    }
+    return current;
+}
+exports.resolvePathValue = resolvePathValue;
+function resolveExpressions(text, context) {
+    return text.replace(/\{\{(.+?)\}\}/g, (match, path) => {
+        const trimmedPath = path.trim();
+        const value = resolvePathValue(trimmedPath, context);
+        if (value === undefined || value === null) {
+            return match;
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+        return String(value);
+    });
+}
+exports.resolveExpressions = resolveExpressions;
+function isTruthy(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return value !== 0;
+    }
+    if (typeof value === 'string') {
+        return value.length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return true;
+}
+exports.isTruthy = isTruthy;

package/dist/workflow/expression/expression-tokenizer.utils.d.ts

@@ -0,0 +1,4 @@
+import { ExpressionToken, DataSourceType } from './expression.types';
+export declare function detectDataSource(path: string): DataSourceType | null;
+export declare function tokenize(text: string): ExpressionToken[];
+export declare function parsePathSegments(path: string): string[];