@abyss-project/console 1.0.41 → 1.0.43

package/dist/workflow-expressions/functions/string.js

@@ -1,301 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringFunctions = void 0;
-exports.stringFunctions = {
-    toUpperCase: {
-        name: 'toUpperCase',
-        description: 'Converts a string to uppercase',
-        category: 'string',
-        signature: 'toUpperCase(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.toUpperCase(trigger.body.username)}}'],
-        execute: (str) => String(str).toUpperCase(),
-    },
-    toLowerCase: {
-        name: 'toLowerCase',
-        description: 'Converts a string to lowercase',
-        category: 'string',
-        signature: 'toLowerCase(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.toLowerCase(trigger.email)}}'],
-        execute: (str) => String(str).toLowerCase(),
-    },
-    trim: {
-        name: 'trim',
-        description: 'Removes whitespace from both ends of a string',
-        category: 'string',
-        signature: 'trim(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.trim(trigger.input)}}'],
-        execute: (str) => String(str).trim(),
-    },
-    substring: {
-        name: 'substring',
-        description: 'Extracts a portion of a string',
-        category: 'string',
-        signature: 'substring(str, start, end?)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-            {
-                name: 'start',
-                type: 'number',
-                required: true,
-                description: 'Start index',
-            },
-            {
-                name: 'end',
-                type: 'number',
-                required: false,
-                description: 'End index',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.substring(trigger.id, 0, 8)}}'],
-        execute: (str, start, end) => {
-            return String(str).substring(Number(start), end !== undefined ? Number(end) : undefined);
-        },
-    },
-    replace: {
-        name: 'replace',
-        description: 'Replaces occurrences of a pattern in a string',
-        category: 'string',
-        signature: 'replace(str, search, replacement)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-            {
-                name: 'search',
-                type: 'string',
-                required: true,
-                description: 'Pattern to search',
-            },
-            {
-                name: 'replacement',
-                type: 'string',
-                required: true,
-                description: 'Replacement string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.replace(trigger.text, "old", "new")}}'],
-        execute: (str, search, replacement) => {
-            const searchStr = String(search);
-            const replaceStr = String(replacement);
-            return String(str).replace(new RegExp(searchStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), replaceStr);
-        },
-    },
-    split: {
-        name: 'split',
-        description: 'Splits a string into an array',
-        category: 'string',
-        signature: 'split(str, separator)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-            {
-                name: 'separator',
-                type: 'string',
-                required: true,
-                description: 'Separator',
-            },
-        ],
-        returnType: 'array',
-        examples: ['{{fn.split(trigger.tags, ",")}}'],
-        execute: (str, separator) => {
-            return String(str).split(String(separator));
-        },
-    },
-    concat: {
-        name: 'concat',
-        description: 'Concatenates multiple strings',
-        category: 'string',
-        signature: 'concat(...strs)',
-        args: [
-            {
-                name: 'strings',
-                type: 'string',
-                required: true,
-                description: 'Strings to concatenate',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.concat("Hello", " ", "World")}}'],
-        execute: (...args) => {
-            return args.map((arg) => String(arg)).join('');
-        },
-    },
-    startsWith: {
-        name: 'startsWith',
-        description: 'Checks if a string starts with a specified value',
-        category: 'string',
-        signature: 'startsWith(str, search)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-            {
-                name: 'search',
-                type: 'string',
-                required: true,
-                description: 'Search value',
-            },
-        ],
-        returnType: 'boolean',
-        examples: ['{{fn.startsWith(trigger.url, "https://")}}'],
-        execute: (str, search) => {
-            return String(str).startsWith(String(search));
-        },
-    },
-    endsWith: {
-        name: 'endsWith',
-        description: 'Checks if a string ends with a specified value',
-        category: 'string',
-        signature: 'endsWith(str, search)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-            {
-                name: 'search',
-                type: 'string',
-                required: true,
-                description: 'Search value',
-            },
-        ],
-        returnType: 'boolean',
-        examples: ['{{fn.endsWith(trigger.filename, ".pdf")}}'],
-        execute: (str, search) => {
-            return String(str).endsWith(String(search));
-        },
-    },
-    includes: {
-        name: 'includes',
-        description: 'Checks if a string contains a specified value',
-        category: 'string',
-        signature: 'includes(str, search)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-            {
-                name: 'search',
-                type: 'string',
-                required: true,
-                description: 'Search value',
-            },
-        ],
-        returnType: 'boolean',
-        examples: ['{{fn.includes(trigger.text, "error")}}'],
-        execute: (str, search) => {
-            return String(str).includes(String(search));
-        },
-    },
-    padStart: {
-        name: 'padStart',
-        description: 'Pads a string from the start to a specified length',
-        category: 'string',
-        signature: 'padStart(str, length, padString?)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-            {
-                name: 'length',
-                type: 'number',
-                required: true,
-                description: 'Target length',
-            },
-            {
-                name: 'padString',
-                type: 'string',
-                required: false,
-                description: 'Padding string (default: space)',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.padStart(trigger.id, 10, "0")}}'],
-        execute: (str, length, padString) => {
-            return String(str).padStart(Number(length), padString !== undefined ? String(padString) : ' ');
-        },
-    },
-    padEnd: {
-        name: 'padEnd',
-        description: 'Pads a string from the end to a specified length',
-        category: 'string',
-        signature: 'padEnd(str, length, padString?)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-            {
-                name: 'length',
-                type: 'number',
-                required: true,
-                description: 'Target length',
-            },
-            {
-                name: 'padString',
-                type: 'string',
-                required: false,
-                description: 'Padding string (default: space)',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.padEnd(trigger.code, 5, "X")}}'],
-        execute: (str, length, padString) => {
-            return String(str).padEnd(Number(length), padString !== undefined ? String(padString) : ' ');
-        },
-    },
-};

package/dist/workflow-expressions/functions/utility.d.ts

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

package/dist/workflow-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.body.username, "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.body.username, "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/workflow-expressions/helpers.d.ts

@@ -1,71 +0,0 @@
-import { DataSourceType, ParsedExpression } from './types';
-export interface ResourceMapping {
-    type: DataSourceType;
-    id: string;
-    name: string;
-    displayPath: string;
-    savePath: string;
-}
-export interface EnrichedToken {
-    type: 'text' | 'expression' | 'error';
-    value: string;
-    rawValue: string;
-    start: number;
-    end: number;
-    parsed?: ParsedExpression;
-    source?: DataSourceType | null;
-    isSecret?: boolean;
-}
-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 tokenizeEnriched(template: string): EnrichedToken[];
-export declare function validateExpression(expression: string, context: Record<string, unknown>): {
-    isValid: boolean;
-    errors: Array<{
-        type: 'error';
-        message: string;
-        start: number;
-        end: number;
-        path?: string;
-    }>;
-    warnings: Array<{
-        type: 'warning';
-        message: string;
-        start: number;
-        end: number;
-        path?: string;
-        suggestion?: string;
-    }>;
-    tokens: EnrichedToken[];
-};
-export declare function generatePreview(expression: string, context: Record<string, unknown>): {
-    value: unknown;
-    type: string;
-    error?: string;
-};
-export declare function convertExpressionToSaveFormat(expression: string, mappings: ResourceMapping[]): string;
-export declare function convertExpressionToDisplayFormat(expression: string, mappings: ResourceMapping[]): string;
-export declare function getValueType(value: unknown): string;
-export {};