@abyss-project/console 1.0.28 → 1.0.30

package/dist/expressions/functions/index.js

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

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

package/dist/expressions/functions/math.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mathFunctions = void 0;
+exports.mathFunctions = {
+    abs: {
+        name: 'abs',
+        description: 'Returns the absolute value of a number',
+        category: 'math',
+        signature: 'abs(num)',
+        args: [
+            {
+                name: 'num',
+                type: 'number',
+                required: true,
+                description: 'Input number',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.abs(-5)}}'],
+        execute: (num) => Math.abs(Number(num)),
+    },
+    ceil: {
+        name: 'ceil',
+        description: 'Rounds a number up to the nearest integer',
+        category: 'math',
+        signature: 'ceil(num)',
+        args: [
+            {
+                name: 'num',
+                type: 'number',
+                required: true,
+                description: 'Input number',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.ceil(4.3)}}'],
+        execute: (num) => Math.ceil(Number(num)),
+    },
+    floor: {
+        name: 'floor',
+        description: 'Rounds a number down to the nearest integer',
+        category: 'math',
+        signature: 'floor(num)',
+        args: [
+            {
+                name: 'num',
+                type: 'number',
+                required: true,
+                description: 'Input number',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.floor(4.7)}}'],
+        execute: (num) => Math.floor(Number(num)),
+    },
+    round: {
+        name: 'round',
+        description: 'Rounds a number to the nearest integer',
+        category: 'math',
+        signature: 'round(num)',
+        args: [
+            {
+                name: 'num',
+                type: 'number',
+                required: true,
+                description: 'Input number',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.round(4.5)}}'],
+        execute: (num) => Math.round(Number(num)),
+    },
+    min: {
+        name: 'min',
+        description: 'Returns the smallest of the given numbers',
+        category: 'math',
+        signature: 'min(...nums)',
+        args: [
+            {
+                name: 'numbers',
+                type: 'number',
+                required: true,
+                description: 'Numbers to compare',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.min(5, 10, 2, 8)}}'],
+        execute: (...args) => Math.min(...args.map(Number)),
+    },
+    max: {
+        name: 'max',
+        description: 'Returns the largest of the given numbers',
+        category: 'math',
+        signature: 'max(...nums)',
+        args: [
+            {
+                name: 'numbers',
+                type: 'number',
+                required: true,
+                description: 'Numbers to compare',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.max(5, 10, 2, 8)}}'],
+        execute: (...args) => Math.max(...args.map(Number)),
+    },
+    pow: {
+        name: 'pow',
+        description: 'Returns the base to the exponent power',
+        category: 'math',
+        signature: 'pow(base, exponent)',
+        args: [
+            {
+                name: 'base',
+                type: 'number',
+                required: true,
+                description: 'Base number',
+            },
+            {
+                name: 'exponent',
+                type: 'number',
+                required: true,
+                description: 'Exponent',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.pow(2, 3)}}'],
+        execute: (base, exponent) => Math.pow(Number(base), Number(exponent)),
+    },
+    sqrt: {
+        name: 'sqrt',
+        description: 'Returns the square root of a number',
+        category: 'math',
+        signature: 'sqrt(num)',
+        args: [
+            {
+                name: 'num',
+                type: 'number',
+                required: true,
+                description: 'Input number',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.sqrt(16)}}'],
+        execute: (num) => Math.sqrt(Number(num)),
+    },
+    random: {
+        name: 'random',
+        description: 'Generates a random integer between min and max (inclusive)',
+        category: 'math',
+        signature: 'random(min, max)',
+        args: [
+            {
+                name: 'min',
+                type: 'number',
+                required: true,
+                description: 'Minimum value',
+            },
+            {
+                name: 'max',
+                type: 'number',
+                required: true,
+                description: 'Maximum value',
+            },
+        ],
+        returnType: 'number',
+        examples: ['{{fn.random(1, 100)}}'],
+        execute: (min, max) => {
+            const minNum = Number(min);
+            const maxNum = Number(max);
+            return Math.floor(Math.random() * (maxNum - minNum + 1)) + minNum;
+        },
+    },
+};

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

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

package/dist/expressions/functions/string.js

@@ -0,0 +1,301 @@
+"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.name)}}'],
+        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/expressions/functions/utility.d.ts

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