@abyss-project/console 1.0.41 → 1.0.43

package/dist/expressions/pipes/array-pipes.js

@@ -1,248 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayPipes = void 0;
-exports.arrayPipes = {
-    first: {
-        name: 'first',
-        description: 'Gets the first element',
-        category: 'array',
-        signature: 'first',
-        examples: ['{{trigger.items | first}}'],
-        execute: (value) => {
-            if (Array.isArray(value) && value.length > 0) {
-                return value[0];
-            }
-            return undefined;
-        },
-    },
-    last: {
-        name: 'last',
-        description: 'Gets the last element',
-        category: 'array',
-        signature: 'last',
-        examples: ['{{trigger.items | last}}'],
-        execute: (value) => {
-            if (Array.isArray(value) && value.length > 0) {
-                return value[value.length - 1];
-            }
-            return undefined;
-        },
-    },
-    length: {
-        name: 'length',
-        description: 'Returns the length',
-        category: 'array',
-        signature: 'length',
-        examples: ['{{trigger.items | length}}'],
-        execute: (value) => {
-            if (Array.isArray(value)) {
-                return value.length;
-            }
-            if (typeof value === 'string') {
-                return value.length;
-            }
-            return 0;
-        },
-    },
-    join: {
-        name: 'join',
-        description: 'Joins array elements',
-        category: 'array',
-        signature: 'join(separator?)',
-        examples: ['{{trigger.tags | join(", ")}}'],
-        execute: (value, separator) => {
-            if (!Array.isArray(value)) {
-                return '';
-            }
-            return value.join(separator !== undefined ? String(separator) : ',');
-        },
-    },
-    slice: {
-        name: 'slice',
-        description: 'Extracts a section',
-        category: 'array',
-        signature: 'slice(start, end?)',
-        examples: ['{{trigger.items | slice(0, 3)}}'],
-        execute: (value, start, end) => {
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            return value.slice(Number(start), end !== undefined ? Number(end) : undefined);
-        },
-    },
-    reverse: {
-        name: 'reverse',
-        description: 'Reverses the order',
-        category: 'array',
-        signature: 'reverse',
-        examples: ['{{trigger.items | reverse}}'],
-        execute: (value) => {
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            return [...value].reverse();
-        },
-    },
-    sort: {
-        name: 'sort',
-        description: 'Sorts the array',
-        category: 'array',
-        signature: 'sort',
-        examples: ['{{trigger.numbers | sort}}'],
-        execute: (value) => {
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            return [...value].sort();
-        },
-    },
-    unique: {
-        name: 'unique',
-        description: 'Returns unique elements',
-        category: 'array',
-        signature: 'unique',
-        examples: ['{{trigger.tags | unique}}'],
-        execute: (value) => {
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            return Array.from(new Set(value));
-        },
-    },
-    flatten: {
-        name: 'flatten',
-        description: 'Flattens nested arrays',
-        category: 'array',
-        signature: 'flatten',
-        examples: ['{{trigger.nested | flatten}}'],
-        execute: (value) => {
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            return value.flat();
-        },
-    },
-    compact: {
-        name: 'compact',
-        description: 'Removes falsy values',
-        category: 'array',
-        signature: 'compact',
-        examples: ['{{trigger.items | compact}}'],
-        execute: (value) => {
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            return value.filter(Boolean);
-        },
-    },
-    sum: {
-        name: 'sum',
-        description: 'Sums numeric values',
-        category: 'array',
-        signature: 'sum',
-        examples: ['{{trigger.numbers | sum}}'],
-        execute: (value) => {
-            if (!Array.isArray(value)) {
-                return 0;
-            }
-            return value.reduce((acc, val) => acc + Number(val), 0);
-        },
-    },
-    avg: {
-        name: 'avg',
-        description: 'Calculates average',
-        category: 'array',
-        signature: 'avg',
-        examples: ['{{trigger.scores | avg}}'],
-        execute: (value) => {
-            if (!Array.isArray(value) || value.length === 0) {
-                return 0;
-            }
-            const sum = value.reduce((acc, val) => acc + Number(val), 0);
-            return sum / value.length;
-        },
-    },
-    min: {
-        name: 'min',
-        description: 'Returns minimum value',
-        category: 'array',
-        signature: 'min',
-        examples: ['{{trigger.numbers | min}}'],
-        execute: (value) => {
-            if (!Array.isArray(value) || value.length === 0) {
-                return undefined;
-            }
-            return Math.min(...value.map(Number));
-        },
-    },
-    max: {
-        name: 'max',
-        description: 'Returns maximum value',
-        category: 'array',
-        signature: 'max',
-        examples: ['{{trigger.numbers | max}}'],
-        execute: (value) => {
-            if (!Array.isArray(value) || value.length === 0) {
-                return undefined;
-            }
-            return Math.max(...value.map(Number));
-        },
-    },
-    map: {
-        name: 'map',
-        description: 'Maps over array elements',
-        category: 'array',
-        signature: 'map(property)',
-        examples: ['{{trigger.users | map("name")}}'],
-        execute: (value, property) => {
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            const prop = String(property);
-            return value.map((item) => {
-                if (item && typeof item === 'object') {
-                    return item[prop];
-                }
-                return undefined;
-            });
-        },
-    },
-    filter: {
-        name: 'filter',
-        description: 'Filters array elements by property',
-        category: 'array',
-        signature: 'filter(property, value)',
-        examples: ['{{trigger.users | filter("active", true)}}'],
-        execute: (value, property, filterValue) => {
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            const prop = String(property);
-            return value.filter((item) => {
-                if (item && typeof item === 'object') {
-                    return item[prop] === filterValue;
-                }
-                return false;
-            });
-        },
-    },
-    pluck: {
-        name: 'pluck',
-        description: 'Extracts property from each object',
-        category: 'array',
-        signature: 'pluck(property)',
-        examples: ['{{trigger.users | pluck("email")}}'],
-        execute: (value, property) => {
-            if (!Array.isArray(value)) {
-                return [];
-            }
-            const prop = String(property);
-            return value.map((item) => {
-                if (item && typeof item === 'object') {
-                    return item[prop];
-                }
-                return undefined;
-            });
-        },
-    },
-};

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

@@ -1,8 +0,0 @@
-import type { PipeDefinition } from './string-pipes';
-import type { OperationCategory } from '../types';
-export declare const PIPE_OPERATIONS: Record<string, PipeDefinition>;
-export declare function executePipeOperation(name: string, value: unknown, args: unknown[]): unknown;
-export declare function getPipesByCategory(category: OperationCategory): Record<string, PipeDefinition>;
-export declare function getPipeNames(): string[];
-export declare function hasPipe(name: string): boolean;
-export declare function getPipe(name: string): PipeDefinition | undefined;

package/dist/expressions/pipes/index.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPipe = exports.hasPipe = exports.getPipeNames = exports.getPipesByCategory = exports.executePipeOperation = exports.PIPE_OPERATIONS = void 0;
-const string_pipes_1 = require("./string-pipes");
-const array_pipes_1 = require("./array-pipes");
-const object_pipes_1 = require("./object-pipes");
-exports.PIPE_OPERATIONS = {
-    ...string_pipes_1.stringPipes,
-    ...array_pipes_1.arrayPipes,
-    ...object_pipes_1.objectPipes,
-};
-function executePipeOperation(name, value, args) {
-    const pipe = exports.PIPE_OPERATIONS[name];
-    if (!pipe) {
-        throw new Error(`Unknown pipe operation: ${name}`);
-    }
-    return pipe.execute(value, ...args);
-}
-exports.executePipeOperation = executePipeOperation;
-function getPipesByCategory(category) {
-    return Object.entries(exports.PIPE_OPERATIONS)
-        .filter(([, pipe]) => pipe.category === category)
-        .reduce((acc, [name, pipe]) => {
-        acc[name] = pipe;
-        return acc;
-    }, {});
-}
-exports.getPipesByCategory = getPipesByCategory;
-function getPipeNames() {
-    return Object.keys(exports.PIPE_OPERATIONS);
-}
-exports.getPipeNames = getPipeNames;
-function hasPipe(name) {
-    return name in exports.PIPE_OPERATIONS;
-}
-exports.hasPipe = hasPipe;
-function getPipe(name) {
-    return exports.PIPE_OPERATIONS[name];
-}
-exports.getPipe = getPipe;

package/dist/expressions/pipes/object-pipes.d.ts

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

package/dist/expressions/pipes/object-pipes.js

@@ -1,243 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectPipes = void 0;
-exports.objectPipes = {
-    keys: {
-        name: 'keys',
-        description: 'Returns object keys',
-        category: 'object',
-        signature: 'keys',
-        examples: ['{{trigger.data | keys}}'],
-        execute: (value) => {
-            if (value && typeof value === 'object') {
-                return Object.keys(value);
-            }
-            return [];
-        },
-    },
-    values: {
-        name: 'values',
-        description: 'Returns object values',
-        category: 'object',
-        signature: 'values',
-        examples: ['{{trigger.data | values}}'],
-        execute: (value) => {
-            if (value && typeof value === 'object') {
-                return Object.values(value);
-            }
-            return [];
-        },
-    },
-    entries: {
-        name: 'entries',
-        description: 'Returns key-value pairs',
-        category: 'object',
-        signature: 'entries',
-        examples: ['{{trigger.data | entries}}'],
-        execute: (value) => {
-            if (value && typeof value === 'object') {
-                return Object.entries(value);
-            }
-            return [];
-        },
-    },
-    get: {
-        name: 'get',
-        description: 'Gets a property value',
-        category: 'object',
-        signature: 'get(path)',
-        examples: ['{{trigger.data | get("user.name")}}'],
-        execute: (value, path) => {
-            if (!value || typeof value !== 'object') {
-                return undefined;
-            }
-            const pathStr = String(path);
-            const keys = pathStr.split('.');
-            let current = value;
-            for (const key of keys) {
-                if (current === null || current === undefined) {
-                    return undefined;
-                }
-                if (typeof current !== 'object') {
-                    return undefined;
-                }
-                current = current[key];
-            }
-            return current;
-        },
-    },
-    has: {
-        name: 'has',
-        description: 'Checks if property exists',
-        category: 'object',
-        signature: 'has(key)',
-        examples: ['{{trigger.data | has("email")}}'],
-        execute: (value, key) => {
-            if (!value || typeof value !== 'object') {
-                return false;
-            }
-            return String(key) in value;
-        },
-    },
-    omit: {
-        name: 'omit',
-        description: 'Omits specified keys',
-        category: 'object',
-        signature: 'omit(...keys)',
-        examples: ['{{trigger.data | omit("password", "token")}}'],
-        execute: (value, ...keys) => {
-            if (!value || typeof value !== 'object') {
-                return value;
-            }
-            const obj = value;
-            const keysToOmit = new Set(keys.map(String));
-            return Object.entries(obj).reduce((acc, [key, val]) => {
-                if (!keysToOmit.has(key)) {
-                    acc[key] = val;
-                }
-                return acc;
-            }, {});
-        },
-    },
-    pick: {
-        name: 'pick',
-        description: 'Picks specified keys',
-        category: 'object',
-        signature: 'pick(...keys)',
-        examples: ['{{trigger.data | pick("id", "name", "email")}}'],
-        execute: (value, ...keys) => {
-            if (!value || typeof value !== 'object') {
-                return {};
-            }
-            const obj = value;
-            const keysToPick = keys.map(String);
-            return keysToPick.reduce((acc, key) => {
-                if (key in obj) {
-                    acc[key] = obj[key];
-                }
-                return acc;
-            }, {});
-        },
-    },
-    merge: {
-        name: 'merge',
-        description: 'Merges with another object',
-        category: 'object',
-        signature: 'merge(object)',
-        examples: ['{{trigger.data | merge(trigger.defaults)}}'],
-        execute: (value, other) => {
-            if (!value || typeof value !== 'object') {
-                return other || {};
-            }
-            if (!other || typeof other !== 'object') {
-                return value;
-            }
-            return { ...value, ...other };
-        },
-    },
-    base64: {
-        name: 'base64',
-        description: 'Encodes to base64',
-        category: 'encoding',
-        signature: 'base64',
-        examples: ['{{trigger.text | base64}}'],
-        execute: (value) => {
-            return Buffer.from(String(value)).toString('base64');
-        },
-    },
-    base64decode: {
-        name: 'base64decode',
-        description: 'Decodes from base64',
-        category: 'encoding',
-        signature: 'base64decode',
-        examples: ['{{trigger.encoded | base64decode}}'],
-        execute: (value) => {
-            try {
-                return Buffer.from(String(value), 'base64').toString('utf-8');
-            }
-            catch {
-                return value;
-            }
-        },
-    },
-    urlEncode: {
-        name: 'urlEncode',
-        description: 'URL encodes a string',
-        category: 'encoding',
-        signature: 'urlEncode',
-        examples: ['{{trigger.query | urlEncode}}'],
-        execute: (value) => {
-            return encodeURIComponent(String(value));
-        },
-    },
-    urlDecode: {
-        name: 'urlDecode',
-        description: 'URL decodes a string',
-        category: 'encoding',
-        signature: 'urlDecode',
-        examples: ['{{trigger.encoded | urlDecode}}'],
-        execute: (value) => {
-            try {
-                return decodeURIComponent(String(value));
-            }
-            catch {
-                return value;
-            }
-        },
-    },
-    json: {
-        name: 'json',
-        description: 'Converts to JSON string',
-        category: 'formatting',
-        signature: 'json',
-        examples: ['{{trigger.data | json}}'],
-        execute: (value) => {
-            return JSON.stringify(value);
-        },
-    },
-    jsonPretty: {
-        name: 'jsonPretty',
-        description: 'Converts to pretty JSON',
-        category: 'formatting',
-        signature: 'jsonPretty',
-        examples: ['{{trigger.data | jsonPretty}}'],
-        execute: (value) => {
-            return JSON.stringify(value, null, 2);
-        },
-    },
-    parseJson: {
-        name: 'parseJson',
-        description: 'Parses JSON string',
-        category: 'formatting',
-        signature: 'parseJson',
-        examples: ['{{trigger.jsonString | parseJson}}'],
-        execute: (value) => {
-            try {
-                return JSON.parse(String(value));
-            }
-            catch {
-                return value;
-            }
-        },
-    },
-    toFixed: {
-        name: 'toFixed',
-        description: 'Formats number with fixed decimals',
-        category: 'number',
-        signature: 'toFixed(decimals)',
-        examples: ['{{trigger.price | toFixed(2)}}'],
-        execute: (value, decimals) => {
-            return Number(value).toFixed(Number(decimals));
-        },
-    },
-    toPrecision: {
-        name: 'toPrecision',
-        description: 'Formats number with precision',
-        category: 'number',
-        signature: 'toPrecision(precision)',
-        examples: ['{{trigger.value | toPrecision(4)}}'],
-        execute: (value, precision) => {
-            return Number(value).toPrecision(Number(precision));
-        },
-    },
-};

package/dist/expressions/pipes/string-pipes.d.ts

@@ -1,9 +0,0 @@
-export interface PipeDefinition {
-    name: string;
-    description: string;
-    category: 'string' | 'array' | 'object' | 'number' | 'date' | 'encoding' | 'formatting';
-    signature: string;
-    examples: string[];
-    execute: (value: unknown, ...args: unknown[]) => unknown;
-}
-export declare const stringPipes: Record<string, PipeDefinition>;