@n8n/workflow-sdk 0.2.0

package/dist/types/base.d.ts

@@ -0,0 +1,395 @@
+import type { ValidationOptions, ValidationResult } from '../validation/index';
+import type { PluginRegistry } from '../workflow-builder/plugins/registry';
+export interface IDataObject {
+    [key: string]: string | number | boolean | null | undefined | object | IDataObject | Array<string | number | boolean | null | object | IDataObject>;
+}
+export interface BinaryData {
+    [key: string]: {
+        fileName?: string;
+        mimeType?: string;
+        fileExtension?: string;
+        fileSize?: string;
+        data?: string;
+    };
+}
+export interface Item<T = IDataObject> {
+    json: T;
+    binary?: BinaryData;
+}
+export type Items<T = IDataObject> = Array<Item<T>>;
+export interface CredentialReference {
+    name: string;
+    id: string;
+}
+export interface NewCredentialValue {
+    readonly __newCredential: true;
+    readonly name: string;
+}
+export interface PlaceholderValue {
+    readonly __placeholder: true;
+    readonly hint: string;
+}
+export type OnError = 'stopWorkflow' | 'continueRegularOutput' | 'continueErrorOutput';
+export interface WorkflowSettings {
+    timezone?: string;
+    errorWorkflow?: string;
+    saveDataErrorExecution?: 'all' | 'none';
+    saveDataSuccessExecution?: 'all' | 'none';
+    saveManualExecutions?: boolean;
+    saveExecutionProgress?: boolean;
+    executionTimeout?: number;
+    executionOrder?: 'v0' | 'v1';
+    callerPolicy?: 'any' | 'none' | 'workflowsFromAList' | 'workflowsFromSameOwner';
+    callerIds?: string;
+    [key: string]: unknown;
+}
+export type GenericValue = string | object | number | boolean | undefined | null;
+export interface IConnection {
+    node: string;
+    type: string;
+    index: number;
+}
+export type NodeInputConnections = Array<IConnection[] | null>;
+export interface INodeConnections {
+    [key: string]: NodeInputConnections;
+}
+export interface IConnections {
+    [key: string]: INodeConnections;
+}
+export interface NodeJSON {
+    id: string;
+    name?: string;
+    type: string;
+    typeVersion: number;
+    position: [number, number];
+    parameters?: IDataObject;
+    credentials?: Record<string, {
+        id?: string;
+        name: string;
+    }>;
+    disabled?: boolean;
+    notes?: string;
+    notesInFlow?: boolean;
+    executeOnce?: boolean;
+    retryOnFail?: boolean;
+    alwaysOutputData?: boolean;
+    onError?: OnError;
+}
+export interface WorkflowJSON {
+    id?: string;
+    name: string;
+    nodes: NodeJSON[];
+    connections: IConnections;
+    settings?: WorkflowSettings;
+    pinData?: Record<string, IDataObject[]>;
+    meta?: {
+        templateId?: string;
+        instanceId?: string;
+    };
+}
+export interface ConnectionTarget {
+    node: string;
+    type: string;
+    index: number;
+}
+export interface GraphNode {
+    instance: NodeInstance<string, string, unknown>;
+    connections: Map<string, Map<number, ConnectionTarget[]>>;
+}
+export interface DeclaredConnection {
+    target: NodeInstance<string, string, unknown> | InputTarget;
+    outputIndex: number;
+    targetInputIndex?: number;
+}
+export interface InputTarget {
+    readonly _isInputTarget: true;
+    readonly node: NodeInstance<string, string, unknown>;
+    readonly inputIndex: number;
+}
+export interface OutputSelector<TType extends string, TVersion extends string, TOutput = unknown> {
+    readonly _isOutputSelector: true;
+    readonly node: NodeInstance<TType, TVersion, TOutput>;
+    readonly outputIndex: number;
+    to<T extends NodeInstance<string, string, unknown>>(target: T | T[] | InputTarget): NodeChain<NodeInstance<TType, TVersion, TOutput>, T>;
+}
+export interface BinaryField {
+    fileName?: string;
+    directory?: string;
+    mimeType?: string;
+    fileExtension?: string;
+    fileSize?: string;
+}
+export type BinaryContext = {
+    [fieldName: string]: BinaryField | (() => string[]);
+} & {
+    keys(): string[];
+};
+export interface InputContext {
+    first(): IDataObject;
+    all(): IDataObject[];
+    item: IDataObject;
+}
+export interface ExecutionContext {
+    id: string;
+    mode: 'test' | 'production';
+    resumeUrl?: string;
+}
+export interface WorkflowContext {
+    id?: string;
+    name?: string;
+    active: boolean;
+}
+export interface ExpressionContext {
+    json: IDataObject;
+    binary: BinaryContext;
+    input: InputContext;
+    env: IDataObject;
+    vars: IDataObject;
+    secrets: IDataObject;
+    now: Date;
+    today: Date;
+    itemIndex: number;
+    runIndex: number;
+    execution: ExecutionContext;
+    workflow: WorkflowContext;
+}
+export type Expression<T> = ($: ExpressionContext) => T;
+export interface NodeConfig<TParams = IDataObject> {
+    parameters?: TParams;
+    credentials?: Record<string, CredentialReference | NewCredentialValue>;
+    name?: string;
+    position?: [number, number];
+    disabled?: boolean;
+    notes?: string;
+    notesInFlow?: boolean;
+    executeOnce?: boolean;
+    retryOnFail?: boolean;
+    alwaysOutputData?: boolean;
+    onError?: OnError;
+    pinData?: IDataObject[];
+    output?: IDataObject[];
+    subnodes?: SubnodeConfig;
+}
+export interface StickyNoteConfig {
+    color?: number;
+    position?: [number, number];
+    width?: number;
+    height?: number;
+    name?: string;
+}
+export interface SubnodeConfig {
+    model?: LanguageModelInstance | LanguageModelInstance[];
+    memory?: MemoryInstance;
+    tools?: ToolInstance[];
+    outputParser?: OutputParserInstance;
+    embedding?: EmbeddingInstance | EmbeddingInstance[];
+    embeddings?: EmbeddingInstance | EmbeddingInstance[];
+    vectorStore?: VectorStoreInstance;
+    retriever?: RetrieverInstance;
+    documentLoader?: DocumentLoaderInstance | DocumentLoaderInstance[];
+    textSplitter?: TextSplitterInstance;
+    reranker?: RerankerInstance;
+}
+export interface NodeInstance<TType extends string, TVersion extends string, TOutput = unknown> {
+    readonly type: TType;
+    readonly version: TVersion;
+    readonly config: NodeConfig;
+    readonly id: string;
+    readonly name: string;
+    readonly _outputType?: TOutput;
+    update(config: Partial<NodeConfig>): NodeInstance<TType, TVersion, TOutput>;
+    to<T extends NodeInstance<string, string, unknown>>(target: T | T[] | InputTarget, outputIndex?: number): NodeChain<NodeInstance<TType, TVersion, TOutput>, T>;
+    to<T>(target: IfElseBuilder<T>, outputIndex?: number): NodeChain<NodeInstance<TType, TVersion, TOutput>, NodeInstance<'n8n-nodes-base.if', string, T>>;
+    to<T>(target: SwitchCaseBuilder<T>, outputIndex?: number): NodeChain<NodeInstance<TType, TVersion, TOutput>, NodeInstance<'n8n-nodes-base.switch', string, T>>;
+    to<T>(target: SplitInBatchesBuilder<T>, outputIndex?: number): NodeChain<NodeInstance<TType, TVersion, TOutput>, NodeInstance<TType, TVersion, TOutput>>;
+    input(index: number): InputTarget;
+    output(index: number): OutputSelector<TType, TVersion, TOutput>;
+    onTrue?(target: IfElseTarget): IfElseBuilder<TOutput>;
+    onFalse?(target: IfElseTarget): IfElseBuilder<TOutput>;
+    onCase?(index: number, target: SwitchCaseTarget): SwitchCaseBuilder<TOutput>;
+    onError<T extends NodeInstance<string, string, unknown>>(handler: T): this;
+    getConnections(): DeclaredConnection[];
+}
+export interface TriggerInstance<TType extends string, TVersion extends string, TOutput = unknown> extends NodeInstance<TType, TVersion, TOutput> {
+    readonly isTrigger: true;
+}
+export interface NodeChain<THead extends NodeInstance<string, string, unknown> = NodeInstance<string, string, unknown>, TTail extends NodeInstance<string, string, unknown> = NodeInstance<string, string, unknown>> extends NodeInstance<TTail['type'], TTail['version'], TTail['_outputType']> {
+    readonly _isChain: true;
+    readonly head: THead;
+    readonly tail: TTail;
+    readonly allNodes: Array<NodeInstance<string, string, unknown>>;
+    to<T extends NodeInstance<string, string, unknown>>(target: T | T[] | InputTarget, outputIndex?: number): NodeChain<THead, T>;
+    to<T>(target: IfElseBuilder<T>, outputIndex?: number): NodeChain<THead, NodeInstance<'n8n-nodes-base.if', string, T>>;
+    to<T>(target: SwitchCaseBuilder<T>, outputIndex?: number): NodeChain<THead, NodeInstance<'n8n-nodes-base.switch', string, T>>;
+    to<T>(target: SplitInBatchesBuilder<T>, outputIndex?: number): NodeChain<THead, TTail>;
+}
+export declare function isNodeChain(value: unknown): value is NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>>;
+export declare function isNodeInstance(value: unknown): value is NodeInstance<string, string, unknown>;
+export interface SubnodeInstance<TType extends string, TVersion extends string, TOutput, TSubnodeType extends string> extends NodeInstance<TType, TVersion, TOutput> {
+    readonly _subnodeType: TSubnodeType;
+}
+export type LanguageModelInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_languageModel'>;
+export type MemoryInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_memory'>;
+export type ToolInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_tool'>;
+export type OutputParserInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_outputParser'>;
+export type EmbeddingInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_embedding'>;
+export type VectorStoreInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_vectorStore'>;
+export type RetrieverInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_retriever'>;
+export type DocumentLoaderInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_document'>;
+export type TextSplitterInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_textSplitter'>;
+export type RerankerInstance<TType extends string = string, TVersion extends string = string, TOutput = unknown> = SubnodeInstance<TType, TVersion, TOutput, 'ai_reranker'>;
+export interface IfElseConfig {
+    version: number;
+    config?: NodeConfig;
+}
+export interface IfElseComposite {
+    readonly ifNode: NodeInstance<'n8n-nodes-base.if', string, unknown>;
+    readonly trueBranch: NodeInstance<string, string, unknown> | Array<NodeInstance<string, string, unknown>>;
+    readonly falseBranch: NodeInstance<string, string, unknown> | Array<NodeInstance<string, string, unknown>>;
+}
+export interface SwitchCaseConfig {
+    version: number;
+    config?: NodeConfig;
+}
+export interface SwitchCaseComposite {
+    readonly switchNode: NodeInstance<'n8n-nodes-base.switch', string, unknown>;
+    readonly cases: Array<NodeInstance<string, string, unknown> | Array<NodeInstance<string, string, unknown>> | null>;
+}
+export type IfElseTarget = null | NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>> | Array<NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>>> | IfElseBuilder<unknown> | SwitchCaseBuilder<unknown>;
+export type SwitchCaseTarget = null | NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>> | Array<NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>>> | IfElseBuilder<unknown> | SwitchCaseBuilder<unknown>;
+export interface IfElseBuilder<TOutput = unknown> {
+    readonly _isIfElseBuilder: true;
+    readonly ifNode: NodeInstance<'n8n-nodes-base.if', string, TOutput>;
+    readonly trueBranch: IfElseTarget;
+    readonly falseBranch: IfElseTarget;
+    onTrue(target: IfElseTarget): IfElseBuilder<TOutput>;
+    onFalse(target: IfElseTarget): IfElseBuilder<TOutput>;
+    to<T extends NodeInstance<string, string, unknown>>(target: T | T[], outputIndex?: number): NodeChain<NodeInstance<'n8n-nodes-base.if', string, TOutput>, T>;
+}
+export interface SwitchCaseBuilder<TOutput = unknown> {
+    readonly _isSwitchCaseBuilder: true;
+    readonly switchNode: NodeInstance<'n8n-nodes-base.switch', string, TOutput>;
+    readonly caseMapping: Map<number, SwitchCaseTarget>;
+    onCase(index: number, target: SwitchCaseTarget): SwitchCaseBuilder<TOutput>;
+    to<T extends NodeInstance<string, string, unknown>>(target: T | T[], outputIndex?: number): NodeChain<NodeInstance<'n8n-nodes-base.switch', string, TOutput>, T>;
+}
+export interface SplitInBatchesFactoryConfig {
+    version: number | string;
+    config?: NodeConfig;
+}
+export interface SplitInBatchesConfig extends NodeConfig {
+    version?: number | string;
+    id?: string;
+}
+export interface SplitInBatchesBuilder<TOutput = unknown> {
+    readonly sibNode: NodeInstance<'n8n-nodes-base.splitInBatches', string, unknown>;
+    onEachBatch(target: null | NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>> | Array<NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>>>): SplitInBatchesBuilder<TOutput>;
+    onDone(target: null | NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>> | Array<NodeInstance<string, string, unknown> | NodeChain<NodeInstance<string, string, unknown>, NodeInstance<string, string, unknown>>>): SplitInBatchesBuilder<TOutput>;
+}
+export interface GeneratePinDataOptions {
+    beforeWorkflow?: WorkflowJSON;
+}
+export interface WorkflowBuilder {
+    readonly id: string;
+    readonly name: string;
+    add<N extends NodeInstance<string, string, unknown> | TriggerInstance<string, string, unknown> | NodeChain | IfElseBuilder<unknown> | SwitchCaseBuilder<unknown>>(node: N): WorkflowBuilder;
+    to<N extends NodeInstance<string, string, unknown>>(node: N): WorkflowBuilder;
+    to(inputTarget: InputTarget): WorkflowBuilder;
+    to(ifElse: IfElseComposite): WorkflowBuilder;
+    to(switchCase: SwitchCaseComposite): WorkflowBuilder;
+    to<T>(splitInBatches: SplitInBatchesBuilder<T>): WorkflowBuilder;
+    to<T>(ifElseBuilder: IfElseBuilder<T>): WorkflowBuilder;
+    to<T>(switchCaseBuilder: SwitchCaseBuilder<T>): WorkflowBuilder;
+    to(nodes: Array<NodeInstance<string, string, unknown> | NodeChain | null>): WorkflowBuilder;
+    settings(settings: WorkflowSettings): WorkflowBuilder;
+    connect(source: NodeInstance<string, string, unknown>, sourceOutput: number, target: NodeInstance<string, string, unknown>, targetInput: number): WorkflowBuilder;
+    getNode(name: string): NodeInstance<string, string, unknown> | undefined;
+    validate(options?: ValidationOptions): ValidationResult;
+    toJSON(): WorkflowJSON;
+    toFormat<T>(format: string): T;
+    toString(): string;
+    generatePinData(options?: GeneratePinDataOptions): WorkflowBuilder;
+    regenerateNodeIds(): void;
+}
+export interface WorkflowBuilderOptions {
+    settings?: WorkflowSettings;
+    registry?: PluginRegistry;
+}
+export interface WorkflowBuilderStatic {
+    (id: string, name: string, options?: WorkflowSettings | WorkflowBuilderOptions): WorkflowBuilder;
+    fromJSON(json: WorkflowJSON): WorkflowBuilder;
+}
+export interface NodeInput<TType extends string = string, TVersion extends number = number, TParams = unknown> {
+    type: TType;
+    version: TVersion;
+    config: NodeConfig<TParams>;
+    output?: IDataObject[];
+}
+export interface TriggerInput<TType extends string = string, TVersion extends number = number, TParams = unknown> {
+    type: TType;
+    version: TVersion;
+    config: NodeConfig<TParams>;
+    output?: IDataObject[];
+}
+export type WorkflowFn = WorkflowBuilderStatic;
+export type NodeFn = <TNode extends NodeInput>(input: TNode) => NodeInstance<TNode['type'], `${TNode['version']}`, unknown>;
+export type TriggerFn = <TTrigger extends TriggerInput>(input: TTrigger) => TriggerInstance<TTrigger['type'], `${TTrigger['version']}`, unknown>;
+export type StickyFn = (content: string, nodes?: Array<NodeInstance<string, string, unknown>>, config?: StickyNoteConfig) => NodeInstance<'n8n-nodes-base.stickyNote', 'v1', void>;
+export type PlaceholderFn = (hint: string) => PlaceholderValue;
+export type NewCredentialFn = (name: string) => NewCredentialValue;
+export type IfElseFn = (branches: [
+    NodeInstance<string, string, unknown> | null,
+    NodeInstance<string, string, unknown> | null
+], config?: IfElseConfig) => IfElseComposite;
+export type SwitchCaseFn = (config?: SwitchCaseConfig) => NodeInstance<'n8n-nodes-base.switch', string, unknown>;
+export type SplitInBatchesFn = (configOrNode: SplitInBatchesFactoryConfig | NodeInstance<'n8n-nodes-base.splitInBatches', string, unknown>) => SplitInBatchesBuilder<unknown>;
+export interface AllItemsContext {
+    $input: {
+        all(): IDataObject[];
+        first(): IDataObject;
+        last(): IDataObject;
+        itemMatching(index: number): IDataObject;
+    };
+    $env: IDataObject;
+    $vars: IDataObject;
+    $secrets: IDataObject;
+    $now: Date;
+    $today: Date;
+    $runIndex: number;
+    $execution: ExecutionContext;
+    $workflow: WorkflowContext;
+    (nodeName: string): {
+        json: IDataObject;
+    };
+    $jmespath: (data: unknown, expr: string) => unknown;
+}
+export interface EachItemContext {
+    $input: {
+        item: IDataObject;
+    };
+    $itemIndex: number;
+    $env: IDataObject;
+    $vars: IDataObject;
+    $secrets: IDataObject;
+    $now: Date;
+    $today: Date;
+    $runIndex: number;
+    $execution: ExecutionContext;
+    $workflow: WorkflowContext;
+    (nodeName: string): {
+        json: IDataObject;
+    };
+    $jmespath: (data: unknown, expr: string) => unknown;
+}
+export interface CodeResult<T> {
+    mode: 'runOnceForAllItems' | 'runOnceForEachItem';
+    jsCode: string;
+    _outputType?: T;
+}
+export type RunOnceForAllItemsFn = <T = unknown>(fn: (ctx: AllItemsContext) => Array<{
+    json: T;
+}>) => CodeResult<T>;
+export type RunOnceForEachItemFn = <T = unknown>(fn: (ctx: EachItemContext) => {
+    json: T;
+} | null) => CodeResult<T>;
+export type FromAIArgumentType = 'string' | 'number' | 'boolean' | 'json';

package/dist/types/base.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNodeChain = isNodeChain;
+exports.isNodeInstance = isNodeInstance;
+function isNodeChain(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (!('_isChain' in value))
+        return false;
+    const isChainValue = value._isChain;
+    return isChainValue === true;
+}
+function isNodeInstance(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (!('type' in value && 'version' in value && 'config' in value && 'to' in value)) {
+        return false;
+    }
+    const toProp = value.to;
+    return typeof toProp === 'function';
+}
+//# sourceMappingURL=base.js.map

package/dist/types/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/types/base.ts"],"names":[],"mappings":";;AAghBA,kCAWC;AAKD,wCAQC;AAxBD,SAAgB,WAAW,CAC1B,KAAc;IAKd,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,IAAI,CAAC,CAAC,UAAU,IAAI,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAEzC,MAAM,YAAY,GAAI,KAAiC,CAAC,QAAQ,CAAC;IACjE,OAAO,YAAY,KAAK,IAAI,CAAC;AAC9B,CAAC;AAKD,SAAgB,cAAc,CAAC,KAAc;IAC5C,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,IAAI,CAAC,CAAC,MAAM,IAAI,KAAK,IAAI,SAAS,IAAI,KAAK,IAAI,QAAQ,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;QACpF,OAAO,KAAK,CAAC;IACd,CAAC;IAED,MAAM,MAAM,GAAI,KAAiC,CAAC,EAAE,CAAC;IACrD,OAAO,OAAO,MAAM,KAAK,UAAU,CAAC;AACrC,CAAC"}

package/dist/utils/code-helpers.d.ts

@@ -0,0 +1,7 @@
+import type { CodeResult, AllItemsContext, EachItemContext } from '../types/base';
+export declare function runOnceForAllItems<T = unknown>(fn: (ctx: AllItemsContext) => Array<{
+    json: T;
+}>): CodeResult<T>;
+export declare function runOnceForEachItem<T = unknown>(fn: (ctx: EachItemContext) => {
+    json: T;
+} | null): CodeResult<T>;

package/dist/utils/code-helpers.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOnceForAllItems = runOnceForAllItems;
+exports.runOnceForEachItem = runOnceForEachItem;
+function extractFunctionBody(fn) {
+    const fnStr = fn.toString();
+    const arrowMatch = fnStr.match(/^\s*\(?(\w+)\)?\s*=>\s*(.+)$/s);
+    if (arrowMatch) {
+        const paramName = arrowMatch[1];
+        let body = arrowMatch[2].trim();
+        if (body.startsWith('{') && body.endsWith('}')) {
+            body = body.slice(1, -1).trim();
+        }
+        else {
+            body = `return ${body};`;
+        }
+        body = body.replace(new RegExp(`${paramName}\\.\\$`, 'g'), '$');
+        body = body.replace(new RegExp(`${paramName}\\(`, 'g'), '$(');
+        body = body.replace(new RegExp(`${paramName}\\.`, 'g'), '');
+        return body;
+    }
+    const funcMatch = fnStr.match(/function\s*\(\s*(\w+)\s*\)\s*\{([\s\S]*)\}$/);
+    if (funcMatch) {
+        const paramName = funcMatch[1];
+        let body = funcMatch[2].trim();
+        body = body.replace(new RegExp(`${paramName}\\.\\$`, 'g'), '$');
+        body = body.replace(new RegExp(`${paramName}\\(`, 'g'), '$(');
+        body = body.replace(new RegExp(`${paramName}\\.`, 'g'), '');
+        return body;
+    }
+    throw new Error('Unable to parse function body');
+}
+function runOnceForAllItems(fn) {
+    const jsCode = extractFunctionBody(fn);
+    return {
+        mode: 'runOnceForAllItems',
+        jsCode,
+    };
+}
+function runOnceForEachItem(fn) {
+    const jsCode = extractFunctionBody(fn);
+    return {
+        mode: 'runOnceForEachItem',
+        jsCode,
+    };
+}
+//# sourceMappingURL=code-helpers.js.map

package/dist/utils/code-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-helpers.js","sourceRoot":"","sources":["../../src/utils/code-helpers.ts"],"names":[],"mappings":";;AA8EA,gDASC;AA2BD,gDASC;AArHD,SAAS,mBAAmB,CAAC,EAAY;IACxC,MAAM,KAAK,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;IAG5B,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,+BAA+B,CAAC,CAAC;IAChE,IAAI,UAAU,EAAE,CAAC;QAChB,MAAM,SAAS,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;QAChC,IAAI,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAGhC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAChD,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACjC,CAAC;aAAM,CAAC;YAEP,IAAI,GAAG,UAAU,IAAI,GAAG,CAAC;QAC1B,CAAC;QAKD,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,QAAQ,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;QAChE,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,KAAK,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;QAC9D,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,KAAK,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QAE5D,OAAO,IAAI,CAAC;IACb,CAAC;IAGD,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,6CAA6C,CAAC,CAAC;IAC7E,IAAI,SAAS,EAAE,CAAC;QACf,MAAM,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAI,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAG/B,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,QAAQ,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;QAChE,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,KAAK,EAAE,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;QAC9D,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,KAAK,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QAE5D,OAAO,IAAI,CAAC;IACb,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;AAClD,CAAC;AA8BD,SAAgB,kBAAkB,CACjC,EAAgD;IAEhD,MAAM,MAAM,GAAG,mBAAmB,CAAC,EAAE,CAAC,CAAC;IAEvC,OAAO;QACN,IAAI,EAAE,oBAAoB;QAC1B,MAAM;KACN,CAAC;AACH,CAAC;AA2BD,SAAgB,kBAAkB,CACjC,EAAgD;IAEhD,MAAM,MAAM,GAAG,mBAAmB,CAAC,EAAE,CAAC,CAAC;IAEvC,OAAO;QACN,IAAI,EAAE,oBAAoB;QAC1B,MAAM;KACN,CAAC;AACH,CAAC"}

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { isPlainObject, getProperty, hasProperty } from './safe-access';
+export { runOnceForAllItems, runOnceForEachItem } from './code-helpers';

package/dist/utils/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOnceForEachItem = exports.runOnceForAllItems = exports.hasProperty = exports.getProperty = exports.isPlainObject = void 0;
+var safe_access_1 = require("./safe-access");
+Object.defineProperty(exports, "isPlainObject", { enumerable: true, get: function () { return safe_access_1.isPlainObject; } });
+Object.defineProperty(exports, "getProperty", { enumerable: true, get: function () { return safe_access_1.getProperty; } });
+Object.defineProperty(exports, "hasProperty", { enumerable: true, get: function () { return safe_access_1.hasProperty; } });
+var code_helpers_1 = require("./code-helpers");
+Object.defineProperty(exports, "runOnceForAllItems", { enumerable: true, get: function () { return code_helpers_1.runOnceForAllItems; } });
+Object.defineProperty(exports, "runOnceForEachItem", { enumerable: true, get: function () { return code_helpers_1.runOnceForEachItem; } });
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":";;;AAMA,6CAAwE;AAA/D,4GAAA,aAAa,OAAA;AAAE,0GAAA,WAAW,OAAA;AAAE,0GAAA,WAAW,OAAA;AAChD,+CAAwE;AAA/D,kHAAA,kBAAkB,OAAA;AAAE,kHAAA,kBAAkB,OAAA"}

package/dist/utils/safe-access.d.ts

@@ -0,0 +1,3 @@
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function getProperty<T>(value: unknown, key: string): T | undefined;
+export declare function hasProperty(value: unknown, key: string): boolean;

package/dist/utils/safe-access.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = isPlainObject;
+exports.getProperty = getProperty;
+exports.hasProperty = hasProperty;
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function getProperty(value, key) {
+    if (!isPlainObject(value)) {
+        return undefined;
+    }
+    return value[key];
+}
+function hasProperty(value, key) {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    return key in value;
+}
+//# sourceMappingURL=safe-access.js.map

package/dist/utils/safe-access.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-access.js","sourceRoot":"","sources":["../../src/utils/safe-access.ts"],"names":[],"mappings":";;AASA,sCAEC;AAUD,kCAKC;AAUD,kCAKC;AAhCD,SAAgB,aAAa,CAAC,KAAc;IAC3C,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC7E,CAAC;AAUD,SAAgB,WAAW,CAAI,KAAc,EAAE,GAAW;IACzD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,SAAS,CAAC;IAClB,CAAC;IACD,OAAO,KAAK,CAAC,GAAG,CAAkB,CAAC;AACpC,CAAC;AAUD,SAAgB,WAAW,CAAC,KAAc,EAAE,GAAW;IACtD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC;IACd,CAAC;IACD,OAAO,GAAG,IAAI,KAAK,CAAC;AACrB,CAAC"}

package/dist/utils/trigger-detection.d.ts

@@ -0,0 +1 @@
+export declare function isTriggerNodeType(type: string): boolean;

package/dist/utils/trigger-detection.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTriggerNodeType = isTriggerNodeType;
+const TRIGGER_NODE_TYPES = new Set([
+    'n8n-nodes-base.webhook',
+    'n8n-nodes-base.cron',
+    'n8n-nodes-base.emailReadImap',
+    'n8n-nodes-base.telegramBot',
+    'n8n-nodes-base.start',
+]);
+function isTriggerNodeType(type) {
+    if (TRIGGER_NODE_TYPES.has(type)) {
+        return true;
+    }
+    return type.toLowerCase().includes('trigger');
+}
+//# sourceMappingURL=trigger-detection.js.map

package/dist/utils/trigger-detection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-detection.js","sourceRoot":"","sources":["../../src/utils/trigger-detection.ts"],"names":[],"mappings":";;AA6BA,8CAKC;AAvBD,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC;IAClC,wBAAwB;IACxB,qBAAqB;IACrB,8BAA8B;IAC9B,4BAA4B;IAC5B,sBAAsB;CACtB,CAAC,CAAC;AAYH,SAAgB,iBAAiB,CAAC,IAAY;IAC7C,IAAI,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC;IACb,CAAC;IACD,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;AAC/C,CAAC"}

package/dist/validation/display-options.d.ts

@@ -0,0 +1,18 @@
+export type DisplayConditionOperator = 'eq' | 'not' | 'gte' | 'lte' | 'gt' | 'lt' | 'between' | 'includes' | 'startsWith' | 'endsWith' | 'regex' | 'exists';
+export type DisplayCondition = {
+    _cnd: Partial<Record<DisplayConditionOperator, unknown>>;
+};
+export type DisplayOptions = {
+    show?: Record<string, unknown[]>;
+    hide?: Record<string, unknown[]>;
+};
+export type DisplayOptionsContext = {
+    parameters: Record<string, unknown>;
+    nodeVersion?: number;
+    rootParameters?: Record<string, unknown>;
+    defaults?: Record<string, unknown>;
+    isToolNode?: boolean;
+};
+export declare function checkConditions(conditions: unknown[], actualValues: unknown[]): boolean;
+export declare function getPropertyValue(context: DisplayOptionsContext, propertyName: string): unknown[];
+export declare function matchesDisplayOptions(context: DisplayOptionsContext, displayOptions: DisplayOptions): boolean;