@abyss-project/main 1.0.109 → 1.0.111

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

@@ -1,61 +0,0 @@
-"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

@@ -1,11 +0,0 @@
-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

@@ -1,32 +0,0 @@
-"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

@@ -1,4 +0,0 @@
-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

@@ -1,43 +0,0 @@
-"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

@@ -1,3 +0,0 @@
-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

@@ -1,54 +0,0 @@
-"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

@@ -1,4 +0,0 @@
-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[];

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

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePathSegments = exports.tokenize = exports.detectDataSource = void 0;
-const expression_types_1 = require("./expression.types");
-const EXPRESSION_PATTERN = /\{\{(.+?)\}\}/g;
-const REFERENCE_PATTERN = /@(\w+):([a-zA-Z0-9-_]+)/g;
-const DATA_SOURCE_PREFIXES = {
-    trigger: expression_types_1.DataSourceType.WORKFLOW_TRIGGER,
-    triggerData: expression_types_1.DataSourceType.WORKFLOW_TRIGGER,
-    steps: expression_types_1.DataSourceType.WORKFLOW_STEPS,
-    variables: expression_types_1.DataSourceType.WORKFLOW_VARIABLES,
-    secret: expression_types_1.DataSourceType.SECRETS,
-    ipAddress: expression_types_1.DataSourceType.IP_ADDRESSES,
-    domain: expression_types_1.DataSourceType.DOMAINS,
-    abyss: expression_types_1.DataSourceType.ABYSS_CONFIG,
-    app: expression_types_1.DataSourceType.APPLICATIONS,
-    project: expression_types_1.DataSourceType.PROJECT,
-    env: expression_types_1.DataSourceType.ENV,
-    fn: expression_types_1.DataSourceType.FUNCTIONS,
-};
-function detectDataSource(path) {
-    const firstDot = path.indexOf('.');
-    const firstBracket = path.indexOf('[');
-    let prefix;
-    if (firstDot === -1 && firstBracket === -1) {
-        prefix = path;
-    }
-    else if (firstDot === -1) {
-        prefix = path.substring(0, firstBracket);
-    }
-    else if (firstBracket === -1) {
-        prefix = path.substring(0, firstDot);
-    }
-    else {
-        prefix = path.substring(0, Math.min(firstDot, firstBracket));
-    }
-    return DATA_SOURCE_PREFIXES[prefix] || null;
-}
-exports.detectDataSource = detectDataSource;
-function tokenize(text) {
-    const tokens = [];
-    let lastIndex = 0;
-    const expressionMatches = Array.from(text.matchAll(EXPRESSION_PATTERN));
-    for (const match of expressionMatches) {
-        const matchIndex = match.index;
-        if (matchIndex > lastIndex) {
-            tokens.push({
-                type: 'text',
-                value: text.substring(lastIndex, matchIndex),
-            });
-        }
-        tokens.push({
-            type: 'expression',
-            value: match[1].trim(),
-            raw: match[0],
-        });
-        lastIndex = matchIndex + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        tokens.push({
-            type: 'text',
-            value: text.substring(lastIndex),
-        });
-    }
-    const referenceMatches = Array.from(text.matchAll(REFERENCE_PATTERN));
-    for (const match of referenceMatches) {
-        tokens.push({
-            type: 'reference',
-            entityType: match[1],
-            entityId: match[2],
-        });
-    }
-    return tokens;
-}
-exports.tokenize = tokenize;
-function parsePathSegments(path) {
-    const segments = [];
-    let current = '';
-    let inBrackets = false;
-    let quoteChar = null;
-    for (let i = 0; i < path.length; i++) {
-        const char = path[i];
-        if (quoteChar) {
-            if (char === quoteChar && path[i - 1] !== '\\') {
-                quoteChar = null;
-            }
-            else if (char !== quoteChar) {
-                current += char;
-            }
-        }
-        else if (char === '"' || char === "'") {
-            quoteChar = char;
-        }
-        else if (char === '[') {
-            if (current) {
-                segments.push(current);
-                current = '';
-            }
-            inBrackets = true;
-        }
-        else if (char === ']') {
-            if (current) {
-                segments.push(current);
-                current = '';
-            }
-            inBrackets = false;
-        }
-        else if (char === '.' && !inBrackets) {
-            if (current) {
-                segments.push(current);
-                current = '';
-            }
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current) {
-        segments.push(current);
-    }
-    return segments;
-}
-exports.parsePathSegments = parsePathSegments;

package/dist/workflow/expression/expression.types.d.ts

@@ -1,33 +0,0 @@
-import type { ResourceMapping as GenericResourceMapping } from '../../expressions';
-export declare enum DataSourceType {
-    WORKFLOW_TRIGGER = "trigger",
-    WORKFLOW_STEPS = "steps",
-    WORKFLOW_VARIABLES = "variables",
-    SECRETS = "secret",
-    IP_ADDRESSES = "ipAddress",
-    DOMAINS = "domain",
-    APPLICATIONS = "app",
-    ABYSS_CONFIG = "abyss",
-    PROJECT = "project",
-    ENV = "env",
-    FUNCTIONS = "fn"
-}
-export type WorkflowResourceMapping = GenericResourceMapping<DataSourceType>;
-export interface WorkflowExpressionContext {
-    trigger?: Record<string, unknown>;
-    steps?: Record<string, unknown>;
-    variables?: Record<string, unknown>;
-    secret?: Record<string, unknown>;
-    ipAddress?: Record<string, unknown>;
-    domain?: Record<string, unknown>;
-    app?: Record<string, unknown>;
-    abyss?: Record<string, unknown>;
-    project?: Record<string, unknown>;
-    env?: Record<string, unknown>;
-}
-export interface WorkflowExpressionResult {
-    value: unknown;
-    success: boolean;
-    error?: string;
-    accessedSources: DataSourceType[];
-}

package/dist/workflow/expression/expression.types.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataSourceType = void 0;
-var DataSourceType;
-(function (DataSourceType) {
-    DataSourceType["WORKFLOW_TRIGGER"] = "trigger";
-    DataSourceType["WORKFLOW_STEPS"] = "steps";
-    DataSourceType["WORKFLOW_VARIABLES"] = "variables";
-    DataSourceType["SECRETS"] = "secret";
-    DataSourceType["IP_ADDRESSES"] = "ipAddress";
-    DataSourceType["DOMAINS"] = "domain";
-    DataSourceType["APPLICATIONS"] = "app";
-    DataSourceType["ABYSS_CONFIG"] = "abyss";
-    DataSourceType["PROJECT"] = "project";
-    DataSourceType["ENV"] = "env";
-    DataSourceType["FUNCTIONS"] = "fn";
-})(DataSourceType || (exports.DataSourceType = DataSourceType = {}));

package/dist/workflow/expression/index.d.ts

@@ -1,10 +0,0 @@
-export type { WorkflowResourceMapping, WorkflowExpressionContext, WorkflowExpressionResult, } from './expression.types';
-export { DataSourceType } from './expression.types';
-export { convertToDisplayFormat, convertToSaveFormat, extractMappings, validateExpression, createWorkflowResourceMapping, buildPathSegment, } from './expression-mapper';
-export { resolveWorkflowExpression, isWorkflowExpressionDynamic, extractDataSources, validateWorkflowExpression, } from './workflow-resolver';
-export type { ExpressionMappingOptions, ExpressionParserConfig, ResolverOptions, } from '../../expressions';
-export { parseExpression, stringifyExpression, isDynamicExpression, extractPaths, } from '../../expressions';
-export * from './expression-resolver.utils';
-export * from './expression-tokenizer.utils';
-export * from './expression-functions.utils';
-export * from './expression-mapping.utils';

package/dist/workflow/expression/index.js

@@ -1,40 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractPaths = exports.isDynamicExpression = exports.stringifyExpression = exports.parseExpression = exports.validateWorkflowExpression = exports.extractDataSources = exports.isWorkflowExpressionDynamic = exports.resolveWorkflowExpression = exports.buildPathSegment = exports.createWorkflowResourceMapping = exports.validateExpression = exports.extractMappings = exports.convertToSaveFormat = exports.convertToDisplayFormat = exports.DataSourceType = void 0;
-var expression_types_1 = require("./expression.types");
-Object.defineProperty(exports, "DataSourceType", { enumerable: true, get: function () { return expression_types_1.DataSourceType; } });
-var expression_mapper_1 = require("./expression-mapper");
-Object.defineProperty(exports, "convertToDisplayFormat", { enumerable: true, get: function () { return expression_mapper_1.convertToDisplayFormat; } });
-Object.defineProperty(exports, "convertToSaveFormat", { enumerable: true, get: function () { return expression_mapper_1.convertToSaveFormat; } });
-Object.defineProperty(exports, "extractMappings", { enumerable: true, get: function () { return expression_mapper_1.extractMappings; } });
-Object.defineProperty(exports, "validateExpression", { enumerable: true, get: function () { return expression_mapper_1.validateExpression; } });
-Object.defineProperty(exports, "createWorkflowResourceMapping", { enumerable: true, get: function () { return expression_mapper_1.createWorkflowResourceMapping; } });
-Object.defineProperty(exports, "buildPathSegment", { enumerable: true, get: function () { return expression_mapper_1.buildPathSegment; } });
-var workflow_resolver_1 = require("./workflow-resolver");
-Object.defineProperty(exports, "resolveWorkflowExpression", { enumerable: true, get: function () { return workflow_resolver_1.resolveWorkflowExpression; } });
-Object.defineProperty(exports, "isWorkflowExpressionDynamic", { enumerable: true, get: function () { return workflow_resolver_1.isWorkflowExpressionDynamic; } });
-Object.defineProperty(exports, "extractDataSources", { enumerable: true, get: function () { return workflow_resolver_1.extractDataSources; } });
-Object.defineProperty(exports, "validateWorkflowExpression", { enumerable: true, get: function () { return workflow_resolver_1.validateWorkflowExpression; } });
-var expressions_1 = require("../../expressions");
-Object.defineProperty(exports, "parseExpression", { enumerable: true, get: function () { return expressions_1.parseExpression; } });
-Object.defineProperty(exports, "stringifyExpression", { enumerable: true, get: function () { return expressions_1.stringifyExpression; } });
-Object.defineProperty(exports, "isDynamicExpression", { enumerable: true, get: function () { return expressions_1.isDynamicExpression; } });
-Object.defineProperty(exports, "extractPaths", { enumerable: true, get: function () { return expressions_1.extractPaths; } });
-__exportStar(require("./expression-resolver.utils"), exports);
-__exportStar(require("./expression-tokenizer.utils"), exports);
-__exportStar(require("./expression-functions.utils"), exports);
-__exportStar(require("./expression-mapping.utils"), exports);

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

@@ -1,9 +0,0 @@
-import { type ResolverOptions } from '../../expressions';
-import type { WorkflowExpressionContext, WorkflowExpressionResult, DataSourceType } from './expression.types';
-export declare function resolveWorkflowExpression(expression: string, context: WorkflowExpressionContext, options?: ResolverOptions): WorkflowExpressionResult;
-export declare function isWorkflowExpressionDynamic(expression: string): boolean;
-export declare function extractDataSources(expression: string): DataSourceType[];
-export declare function validateWorkflowExpression(expression: string): {
-    valid: boolean;
-    error?: string;
-};

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

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateWorkflowExpression = exports.extractDataSources = exports.isWorkflowExpressionDynamic = exports.resolveWorkflowExpression = void 0;
-const expressions_1 = require("../../expressions");
-function resolveWorkflowExpression(expression, context, options) {
-    try {
-        const paths = (0, expressions_1.extractPaths)(expression);
-        const accessedSources = new Set();
-        for (const path of paths) {
-            const source = path.split('.')[0];
-            accessedSources.add(source);
-        }
-        const value = (0, expressions_1.resolveExpression)(expression, context, {
-            ...options,
-            functions: {
-                ...workflowFunctions,
-                ...((options === null || options === void 0 ? void 0 : options.functions) || {}),
-            },
-        });
-        return {
-            value,
-            success: true,
-            accessedSources: Array.from(accessedSources),
-        };
-    }
-    catch (error) {
-        return {
-            value: undefined,
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-            accessedSources: [],
-        };
-    }
-}
-exports.resolveWorkflowExpression = resolveWorkflowExpression;
-const workflowFunctions = {
-    upper: (str) => String(str).toUpperCase(),
-    lower: (str) => String(str).toLowerCase(),
-    trim: (str) => String(str).trim(),
-    length: (str) => String(str).length,
-    join: (arr, separator = ',') => {
-        if (!Array.isArray(arr))
-            return String(arr);
-        return arr.join(String(separator));
-    },
-    first: (arr) => {
-        if (!Array.isArray(arr))
-            return arr;
-        return arr[0];
-    },
-    last: (arr) => {
-        if (!Array.isArray(arr))
-            return arr;
-        return arr[arr.length - 1];
-    },
-    now: () => new Date().toISOString(),
-    timestamp: () => Date.now(),
-    json: (obj) => JSON.stringify(obj),
-    default: (value, defaultValue) => {
-        return value === undefined || value === null ? defaultValue : value;
-    },
-};
-function isWorkflowExpressionDynamic(expression) {
-    return (0, expressions_1.isDynamicExpression)(expression);
-}
-exports.isWorkflowExpressionDynamic = isWorkflowExpressionDynamic;
-function extractDataSources(expression) {
-    const paths = (0, expressions_1.extractPaths)(expression);
-    const sources = new Set();
-    for (const path of paths) {
-        const source = path.split('.')[0];
-        sources.add(source);
-    }
-    return Array.from(sources);
-}
-exports.extractDataSources = extractDataSources;
-function validateWorkflowExpression(expression) {
-    try {
-        const openCount = (expression.match(/\{\{/g) || []).length;
-        const closeCount = (expression.match(/\}\}/g) || []).length;
-        if (openCount !== closeCount) {
-            return {
-                valid: false,
-                error: 'Mismatched expression delimiters',
-            };
-        }
-        if (/\{\{\s*\}\}/.test(expression)) {
-            return {
-                valid: false,
-                error: 'Empty expression found',
-            };
-        }
-        return { valid: true };
-    }
-    catch (error) {
-        return {
-            valid: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-exports.validateWorkflowExpression = validateWorkflowExpression;

package/dist/workflow/expressions/functions/array.d.ts

@@ -1,2 +0,0 @@
-import type { BuiltInFunction } from '../types';
-export declare const arrayFunctions: Record<string, BuiltInFunction>;