@abyss-project/console 1.0.40 → 1.0.42

package/dist/expressions/functions/array.js

@@ -1,252 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayFunctions = void 0;
-exports.arrayFunctions = {
-    length: {
-        name: 'length',
-        description: 'Returns the length of a string or array',
-        category: 'array',
-        signature: 'length(value)',
-        args: [
-            {
-                name: 'value',
-                type: 'string|array',
-                required: true,
-                description: 'String or array',
-            },
-        ],
-        returnType: 'number',
-        examples: ['{{fn.length(trigger.items)}}'],
-        execute: (value) => {
-            if (typeof value === 'string') {
-                return value.length;
-            }
-            if (Array.isArray(value)) {
-                return value.length;
-            }
-            return 0;
-        },
-    },
-    first: {
-        name: 'first',
-        description: 'Returns the first element of an array',
-        category: 'array',
-        signature: 'first(arr)',
-        args: [
-            {
-                name: 'arr',
-                type: 'array',
-                required: true,
-                description: 'Input array',
-            },
-        ],
-        returnType: 'any',
-        examples: ['{{fn.first(trigger.items)}}'],
-        execute: (arr) => {
-            if (Array.isArray(arr) && arr.length > 0) {
-                return arr[0];
-            }
-            return undefined;
-        },
-    },
-    last: {
-        name: 'last',
-        description: 'Returns the last element of an array',
-        category: 'array',
-        signature: 'last(arr)',
-        args: [
-            {
-                name: 'arr',
-                type: 'array',
-                required: true,
-                description: 'Input array',
-            },
-        ],
-        returnType: 'any',
-        examples: ['{{fn.last(trigger.items)}}'],
-        execute: (arr) => {
-            if (Array.isArray(arr) && arr.length > 0) {
-                return arr[arr.length - 1];
-            }
-            return undefined;
-        },
-    },
-    join: {
-        name: 'join',
-        description: 'Joins array elements into a string',
-        category: 'array',
-        signature: 'join(arr, separator)',
-        args: [
-            {
-                name: 'arr',
-                type: 'array',
-                required: true,
-                description: 'Input array',
-            },
-            {
-                name: 'separator',
-                type: 'string',
-                required: false,
-                description: 'Separator (default: ",")',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.join(trigger.tags, ", ")}}'],
-        execute: (arr, separator) => {
-            if (!Array.isArray(arr)) {
-                return '';
-            }
-            return arr.join(separator !== undefined ? String(separator) : ',');
-        },
-    },
-    slice: {
-        name: 'slice',
-        description: 'Extracts a section of an array',
-        category: 'array',
-        signature: 'slice(arr, start, end?)',
-        args: [
-            {
-                name: 'arr',
-                type: 'array',
-                required: true,
-                description: 'Input array',
-            },
-            {
-                name: 'start',
-                type: 'number',
-                required: true,
-                description: 'Start index',
-            },
-            {
-                name: 'end',
-                type: 'number',
-                required: false,
-                description: 'End index',
-            },
-        ],
-        returnType: 'array',
-        examples: ['{{fn.slice(trigger.items, 0, 3)}}'],
-        execute: (arr, start, end) => {
-            if (!Array.isArray(arr)) {
-                return [];
-            }
-            return arr.slice(Number(start), end !== undefined ? Number(end) : undefined);
-        },
-    },
-    includes: {
-        name: 'includes',
-        description: 'Checks if an array includes a value',
-        category: 'array',
-        signature: 'includes(arr, value)',
-        args: [
-            {
-                name: 'arr',
-                type: 'array',
-                required: true,
-                description: 'Input array',
-            },
-            {
-                name: 'value',
-                type: 'any',
-                required: true,
-                description: 'Value to search for',
-            },
-        ],
-        returnType: 'boolean',
-        examples: ['{{fn.includes(trigger.roles, "admin")}}'],
-        execute: (arr, value) => {
-            if (!Array.isArray(arr)) {
-                return false;
-            }
-            return arr.includes(value);
-        },
-    },
-    reverse: {
-        name: 'reverse',
-        description: 'Reverses the order of array elements',
-        category: 'array',
-        signature: 'reverse(arr)',
-        args: [
-            {
-                name: 'arr',
-                type: 'array',
-                required: true,
-                description: 'Input array',
-            },
-        ],
-        returnType: 'array',
-        examples: ['{{fn.reverse(trigger.items)}}'],
-        execute: (arr) => {
-            if (!Array.isArray(arr)) {
-                return [];
-            }
-            return [...arr].reverse();
-        },
-    },
-    unique: {
-        name: 'unique',
-        description: 'Returns unique elements from an array',
-        category: 'array',
-        signature: 'unique(arr)',
-        args: [
-            {
-                name: 'arr',
-                type: 'array',
-                required: true,
-                description: 'Input array',
-            },
-        ],
-        returnType: 'array',
-        examples: ['{{fn.unique(trigger.tags)}}'],
-        execute: (arr) => {
-            if (!Array.isArray(arr)) {
-                return [];
-            }
-            return Array.from(new Set(arr));
-        },
-    },
-    flatten: {
-        name: 'flatten',
-        description: 'Flattens a nested array by one level',
-        category: 'array',
-        signature: 'flatten(arr)',
-        args: [
-            {
-                name: 'arr',
-                type: 'array',
-                required: true,
-                description: 'Input array',
-            },
-        ],
-        returnType: 'array',
-        examples: ['{{fn.flatten([[1, 2], [3, 4]])}}'],
-        execute: (arr) => {
-            if (!Array.isArray(arr)) {
-                return [];
-            }
-            return arr.flat();
-        },
-    },
-    compact: {
-        name: 'compact',
-        description: 'Removes falsy values from an array',
-        category: 'array',
-        signature: 'compact(arr)',
-        args: [
-            {
-                name: 'arr',
-                type: 'array',
-                required: true,
-                description: 'Input array',
-            },
-        ],
-        returnType: 'array',
-        examples: ['{{fn.compact([0, 1, false, 2, "", 3])}}'],
-        execute: (arr) => {
-            if (!Array.isArray(arr)) {
-                return [];
-            }
-            return arr.filter(Boolean);
-        },
-    },
-};

package/dist/expressions/functions/crypto.d.ts

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

package/dist/expressions/functions/crypto.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cryptoFunctions = void 0;
-const crypto_1 = require("crypto");
-exports.cryptoFunctions = {
-    md5: {
-        name: 'md5',
-        description: 'Generates an MD5 hash of the input string',
-        category: 'crypto',
-        signature: 'md5(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.md5(trigger.password)}}'],
-        execute: (str) => {
-            return (0, crypto_1.createHash)('md5').update(String(str)).digest('hex');
-        },
-    },
-    sha1: {
-        name: 'sha1',
-        description: 'Generates a SHA-1 hash of the input string',
-        category: 'crypto',
-        signature: 'sha1(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.sha1(trigger.data)}}'],
-        execute: (str) => {
-            return (0, crypto_1.createHash)('sha1').update(String(str)).digest('hex');
-        },
-    },
-    sha256: {
-        name: 'sha256',
-        description: 'Generates a SHA-256 hash of the input string',
-        category: 'crypto',
-        signature: 'sha256(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.sha256(trigger.data)}}'],
-        execute: (str) => {
-            return (0, crypto_1.createHash)('sha256').update(String(str)).digest('hex');
-        },
-    },
-    sha512: {
-        name: 'sha512',
-        description: 'Generates a SHA-512 hash of the input string',
-        category: 'crypto',
-        signature: 'sha512(str)',
-        args: [
-            {
-                name: 'str',
-                type: 'string',
-                required: true,
-                description: 'Input string',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.sha512(trigger.data)}}'],
-        execute: (str) => {
-            return (0, crypto_1.createHash)('sha512').update(String(str)).digest('hex');
-        },
-    },
-    randomBytes: {
-        name: 'randomBytes',
-        description: 'Generates random bytes as a hex string',
-        category: 'crypto',
-        signature: 'randomBytes(size)',
-        args: [
-            {
-                name: 'size',
-                type: 'number',
-                required: true,
-                description: 'Number of bytes',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.randomBytes(16)}}'],
-        execute: (size) => {
-            return (0, crypto_1.randomBytes)(Number(size)).toString('hex');
-        },
-    },
-};

package/dist/expressions/functions/datetime.d.ts

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

package/dist/expressions/functions/datetime.js

@@ -1,256 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.datetimeFunctions = void 0;
-const date_fns_1 = require("date-fns");
-exports.datetimeFunctions = {
-    now: {
-        name: 'now',
-        description: 'Returns the current date and time in ISO format',
-        category: 'datetime',
-        signature: 'now()',
-        args: [],
-        returnType: 'string',
-        examples: ['{{fn.now()}}', '{{now()}}'],
-        execute: () => new Date().toISOString(),
-    },
-    timestamp: {
-        name: 'timestamp',
-        description: 'Returns the current Unix timestamp in milliseconds',
-        category: 'datetime',
-        signature: 'timestamp()',
-        args: [],
-        returnType: 'number',
-        examples: ['{{fn.timestamp()}}', '{{timestamp()}}'],
-        execute: () => Date.now(),
-    },
-    formatDate: {
-        name: 'formatDate',
-        description: 'Formats a date string with the specified format',
-        category: 'datetime',
-        signature: 'formatDate(date, format)',
-        args: [
-            {
-                name: 'date',
-                type: 'string',
-                required: true,
-                description: 'ISO date string',
-            },
-            {
-                name: 'format',
-                type: 'string',
-                required: true,
-                description: 'Format pattern (e.g., yyyy-MM-dd)',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.formatDate(trigger.createdAt, "yyyy-MM-dd")}}'],
-        execute: (date, formatStr) => {
-            const d = new Date(date);
-            return (0, date_fns_1.format)(d, formatStr);
-        },
-    },
-    addDays: {
-        name: 'addDays',
-        description: 'Adds days to a date',
-        category: 'datetime',
-        signature: 'addDays(date, days)',
-        args: [
-            {
-                name: 'date',
-                type: 'string',
-                required: true,
-                description: 'ISO date string',
-            },
-            {
-                name: 'days',
-                type: 'number',
-                required: true,
-                description: 'Number of days to add',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.addDays(fn.now(), 7)}}'],
-        execute: (date, days) => {
-            const d = new Date(date);
-            return (0, date_fns_1.addDays)(d, days).toISOString();
-        },
-    },
-    addHours: {
-        name: 'addHours',
-        description: 'Adds hours to a date',
-        category: 'datetime',
-        signature: 'addHours(date, hours)',
-        args: [
-            {
-                name: 'date',
-                type: 'string',
-                required: true,
-                description: 'ISO date string',
-            },
-            {
-                name: 'hours',
-                type: 'number',
-                required: true,
-                description: 'Number of hours to add',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.addHours(fn.now(), 24)}}'],
-        execute: (date, hours) => {
-            const d = new Date(date);
-            return (0, date_fns_1.addHours)(d, hours).toISOString();
-        },
-    },
-    addMinutes: {
-        name: 'addMinutes',
-        description: 'Adds minutes to a date',
-        category: 'datetime',
-        signature: 'addMinutes(date, minutes)',
-        args: [
-            {
-                name: 'date',
-                type: 'string',
-                required: true,
-                description: 'ISO date string',
-            },
-            {
-                name: 'minutes',
-                type: 'number',
-                required: true,
-                description: 'Number of minutes to add',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.addMinutes(fn.now(), 30)}}'],
-        execute: (date, minutes) => {
-            const d = new Date(date);
-            return (0, date_fns_1.addMinutes)(d, minutes).toISOString();
-        },
-    },
-    addSeconds: {
-        name: 'addSeconds',
-        description: 'Adds seconds to a date',
-        category: 'datetime',
-        signature: 'addSeconds(date, seconds)',
-        args: [
-            {
-                name: 'date',
-                type: 'string',
-                required: true,
-                description: 'ISO date string',
-            },
-            {
-                name: 'seconds',
-                type: 'number',
-                required: true,
-                description: 'Number of seconds to add',
-            },
-        ],
-        returnType: 'string',
-        examples: ['{{fn.addSeconds(fn.now(), 60)}}'],
-        execute: (date, seconds) => {
-            const d = new Date(date);
-            return (0, date_fns_1.addSeconds)(d, seconds).toISOString();
-        },
-    },
-    diffDays: {
-        name: 'diffDays',
-        description: 'Returns the difference in days between two dates',
-        category: 'datetime',
-        signature: 'diffDays(date1, date2)',
-        args: [
-            {
-                name: 'date1',
-                type: 'string',
-                required: true,
-                description: 'First ISO date string',
-            },
-            {
-                name: 'date2',
-                type: 'string',
-                required: true,
-                description: 'Second ISO date string',
-            },
-        ],
-        returnType: 'number',
-        examples: ['{{fn.diffDays(trigger.startDate, fn.now())}}'],
-        execute: (date1, date2) => {
-            return (0, date_fns_1.differenceInDays)(new Date(date1), new Date(date2));
-        },
-    },
-    diffHours: {
-        name: 'diffHours',
-        description: 'Returns the difference in hours between two dates',
-        category: 'datetime',
-        signature: 'diffHours(date1, date2)',
-        args: [
-            {
-                name: 'date1',
-                type: 'string',
-                required: true,
-                description: 'First ISO date string',
-            },
-            {
-                name: 'date2',
-                type: 'string',
-                required: true,
-                description: 'Second ISO date string',
-            },
-        ],
-        returnType: 'number',
-        examples: ['{{fn.diffHours(trigger.startDate, fn.now())}}'],
-        execute: (date1, date2) => {
-            return (0, date_fns_1.differenceInHours)(new Date(date1), new Date(date2));
-        },
-    },
-    diffMinutes: {
-        name: 'diffMinutes',
-        description: 'Returns the difference in minutes between two dates',
-        category: 'datetime',
-        signature: 'diffMinutes(date1, date2)',
-        args: [
-            {
-                name: 'date1',
-                type: 'string',
-                required: true,
-                description: 'First ISO date string',
-            },
-            {
-                name: 'date2',
-                type: 'string',
-                required: true,
-                description: 'Second ISO date string',
-            },
-        ],
-        returnType: 'number',
-        examples: ['{{fn.diffMinutes(trigger.startDate, fn.now())}}'],
-        execute: (date1, date2) => {
-            return (0, date_fns_1.differenceInMinutes)(new Date(date1), new Date(date2));
-        },
-    },
-    diffSeconds: {
-        name: 'diffSeconds',
-        description: 'Returns the difference in seconds between two dates',
-        category: 'datetime',
-        signature: 'diffSeconds(date1, date2)',
-        args: [
-            {
-                name: 'date1',
-                type: 'string',
-                required: true,
-                description: 'First ISO date string',
-            },
-            {
-                name: 'date2',
-                type: 'string',
-                required: true,
-                description: 'Second ISO date string',
-            },
-        ],
-        returnType: 'number',
-        examples: ['{{fn.diffSeconds(trigger.startDate, fn.now())}}'],
-        execute: (date1, date2) => {
-            return (0, date_fns_1.differenceInSeconds)(new Date(date1), new Date(date2));
-        },
-    },
-};

package/dist/expressions/functions/index.d.ts

@@ -1,7 +0,0 @@
-import type { BuiltInFunction, FunctionCategory } from '../types';
-export declare const BUILT_IN_FUNCTIONS: Record<string, BuiltInFunction>;
-export declare function executeFunction(name: string, args: unknown[]): unknown;
-export declare function getFunctionsByCategory(category: FunctionCategory): Record<string, BuiltInFunction>;
-export declare function getFunctionNames(): string[];
-export declare function hasFunction(name: string): boolean;
-export declare function getFunction(name: string): BuiltInFunction | undefined;

package/dist/expressions/functions/index.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunction = exports.hasFunction = exports.getFunctionNames = exports.getFunctionsByCategory = exports.executeFunction = exports.BUILT_IN_FUNCTIONS = void 0;
-const datetime_1 = require("./datetime");
-const string_1 = require("./string");
-const math_1 = require("./math");
-const crypto_1 = require("./crypto");
-const array_1 = require("./array");
-const utility_1 = require("./utility");
-exports.BUILT_IN_FUNCTIONS = {
-    ...datetime_1.datetimeFunctions,
-    ...string_1.stringFunctions,
-    ...math_1.mathFunctions,
-    ...crypto_1.cryptoFunctions,
-    ...array_1.arrayFunctions,
-    ...utility_1.utilityFunctions,
-};
-function executeFunction(name, args) {
-    const func = exports.BUILT_IN_FUNCTIONS[name];
-    if (!func) {
-        throw new Error(`Unknown function: ${name}`);
-    }
-    return func.execute(...args);
-}
-exports.executeFunction = executeFunction;
-function getFunctionsByCategory(category) {
-    return Object.entries(exports.BUILT_IN_FUNCTIONS)
-        .filter(([, func]) => func.category === category)
-        .reduce((acc, [name, func]) => {
-        acc[name] = func;
-        return acc;
-    }, {});
-}
-exports.getFunctionsByCategory = getFunctionsByCategory;
-function getFunctionNames() {
-    return Object.keys(exports.BUILT_IN_FUNCTIONS);
-}
-exports.getFunctionNames = getFunctionNames;
-function hasFunction(name) {
-    return name in exports.BUILT_IN_FUNCTIONS;
-}
-exports.hasFunction = hasFunction;
-function getFunction(name) {
-    return exports.BUILT_IN_FUNCTIONS[name];
-}
-exports.getFunction = getFunction;

package/dist/expressions/functions/math.d.ts

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