@abyss-project/console 1.0.40 → 1.0.42

package/dist/expressions/functions/utility.js

@@ -1,230 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.utilityFunctions = void 0;
-const uuid_1 = require("uuid");
-exports.utilityFunctions = {
-    uuid: {
-        name: 'uuid',
-        description: 'Generates a random UUID v4',
-        category: 'utility',
-        signature: 'uuid()',
-        args: [],
-        returnType: 'string',
-        examples: ['{{fn.uuid()}}', '{{uuid()}}'],
-        execute: () => (0, uuid_1.v4)(),
-    },
-    coalesce: {
-        name: 'coalesce',
-        description: 'Returns the first non-null/undefined value',
-        category: 'utility',
-        signature: 'coalesce(value1, value2, ...)',
-        args: [
-            {
-                name: 'values',
-                type: 'any',
-                required: true,
-                description: 'Values to check',
-            },
-        ],
-        returnType: 'any',
-        examples: ['{{fn.coalesce(trigger.name, "Anonymous")}}'],
-        execute: (...args) => {
-            for (const arg of args) {
-                if (arg !== null && arg !== undefined) {
-                    return arg;
-                }
-            }
-            return null;
-        },
-    },
-    typeOf: {
-        name: 'typeOf',
-        description: 'Returns the type of a value',
-        category: 'utility',
-        signature: 'typeOf(value)',
-        args: [
-            {
-                name: 'value',
-                type: 'any',
-                required: true,
-                description: 'Value to check',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.typeOf(trigger.data)}}'],
-        execute: (value) => {
-            if (value === null)
-                return 'null';
-            if (Array.isArray(value))
-                return 'array';
-            return typeof value;
-        },
-    },
-    isNull: {
-        name: 'isNull',
-        description: 'Checks if a value is null or undefined',
-        category: 'utility',
-        signature: 'isNull(value)',
-        args: [
-            {
-                name: 'value',
-                type: 'any',
-                required: true,
-                description: 'Value to check',
-            },
-        ],
-        returnType: 'boolean',
-        examples: ['{{fn.isNull(trigger.optional)}}'],
-        execute: (value) => value === null || value === undefined,
-    },
-    isEmpty: {
-        name: 'isEmpty',
-        description: 'Checks if a value is empty (null, undefined, empty string, empty array, or empty object)',
-        category: 'utility',
-        signature: 'isEmpty(value)',
-        args: [
-            {
-                name: 'value',
-                type: 'any',
-                required: true,
-                description: 'Value to check',
-            },
-        ],
-        returnType: 'boolean',
-        examples: ['{{fn.isEmpty(trigger.description)}}'],
-        execute: (value) => {
-            if (value === null || value === undefined)
-                return true;
-            if (typeof value === 'string')
-                return value.length === 0;
-            if (Array.isArray(value))
-                return value.length === 0;
-            if (typeof value === 'object')
-                return Object.keys(value).length === 0;
-            return false;
-        },
-    },
-    default: {
-        name: 'default',
-        description: 'Returns a default value if the input is null, undefined, or empty',
-        category: 'utility',
-        signature: 'default(value, defaultValue)',
-        args: [
-            {
-                name: 'value',
-                type: 'any',
-                required: true,
-                description: 'Input value',
-            },
-            {
-                name: 'defaultValue',
-                type: 'any',
-                required: true,
-                description: 'Default value',
-            },
-        ],
-        returnType: 'any',
-        examples: ['{{fn.default(trigger.name, "Unknown")}}'],
-        execute: (value, defaultValue) => {
-            if (value === null || value === undefined)
-                return defaultValue;
-            if (typeof value === 'string' && value.length === 0)
-                return defaultValue;
-            if (Array.isArray(value) && value.length === 0)
-                return defaultValue;
-            return value;
-        },
-    },
-    toNumber: {
-        name: 'toNumber',
-        description: 'Converts a value to a number',
-        category: 'utility',
-        signature: 'toNumber(value)',
-        args: [
-            {
-                name: 'value',
-                type: 'any',
-                required: true,
-                description: 'Value to convert',
-            },
-        ],
-        returnType: 'number',
-        examples: ['{{fn.toNumber(trigger.stringNum)}}'],
-        execute: (value) => Number(value),
-    },
-    toString: {
-        name: 'toString',
-        description: 'Converts a value to a string',
-        category: 'utility',
-        signature: 'toString(value)',
-        args: [
-            {
-                name: 'value',
-                type: 'any',
-                required: true,
-                description: 'Value to convert',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.toString(trigger.number)}}'],
-        execute: (value) => String(value),
-    },
-    toBoolean: {
-        name: 'toBoolean',
-        description: 'Converts a value to a boolean',
-        category: 'utility',
-        signature: 'toBoolean(value)',
-        args: [
-            {
-                name: 'value',
-                type: 'any',
-                required: true,
-                description: 'Value to convert',
-            },
-        ],
-        returnType: 'boolean',
-        examples: ['{{fn.toBoolean(trigger.flag)}}'],
-        execute: (value) => Boolean(value),
-    },
-    parseJSON: {
-        name: 'parseJSON',
-        description: 'Parses a JSON string',
-        category: 'utility',
-        signature: 'parseJSON(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'JSON string',
-            },
-        ],
-        returnType: 'any',
-        examples: ['{{fn.parseJSON(trigger.jsonData)}}'],
-        execute: (str) => {
-            try {
-                return JSON.parse(String(str));
-            }
-            catch {
-                return null;
-            }
-        },
-    },
-    toJSON: {
-        name: 'toJSON',
-        description: 'Converts a value to a JSON string',
-        category: 'utility',
-        signature: 'toJSON(value)',
-        args: [
-            {
-                name: 'value',
-                type: 'any',
-                required: true,
-                description: 'Value to convert',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.toJSON(trigger.data)}}'],
-        execute: (value) => JSON.stringify(value),
-    },
-};

package/dist/expressions/helpers.d.ts

@@ -1,26 +0,0 @@
-export declare function buildExpressionString(path: string, operations?: Array<{
-    name: string;
-    args: unknown[];
-}>): string;
-export declare function buildReferenceString(type: string, id: string): string;
-export declare function hasExpressions(str: string): boolean;
-export declare function hasReferences(str: string): boolean;
-export declare function isInsideExpression(text: string, cursorPos: number): boolean;
-export declare function extractPaths(str: string): string[];
-export declare function parseOperations(opsStr: string): Array<{
-    name: string;
-    args: unknown[];
-}>;
-export declare function getCurrentExpressionContext(text: string, cursorPos: number): {
-    isInExpression: boolean;
-    expressionStart: number;
-    expressionContent: string;
-    cursorOffsetInExpression: number;
-    currentPath: string;
-    expression: string;
-    start: number;
-    end: number;
-    path: string;
-} | null;
-export declare function getValueType(value: unknown): string;
-export {};

package/dist/expressions/helpers.js

@@ -1,132 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValueType = exports.getCurrentExpressionContext = exports.parseOperations = exports.extractPaths = exports.isInsideExpression = exports.hasReferences = exports.hasExpressions = exports.buildReferenceString = exports.buildExpressionString = void 0;
-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 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/expressions/index.d.ts

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

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

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

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

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

@@ -1,97 +0,0 @@
-"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/pipes/array-pipes.d.ts

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