ts2workflows 0.5.0 → 0.7.0

package/dist/transpiler/statements.js

@@ -2,18 +2,18 @@ import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
 import { AssignStepAST, CallStepAST, ForStepAST, JumpTargetAST, NextStepAST, ParallelStepAST, RaiseStepAST, ReturnStepAST, StepsStepAST, SwitchStepAST, TryStepAST, } from '../ast/steps.js';
 import { BinaryExpression, FunctionInvocationExpression, PrimitiveExpression, VariableReferenceExpression, isExpression, isFullyQualifiedName, isLiteral, } from '../ast/expressions.js';
 import { InternalTranspilingError, WorkflowSyntaxError } from '../errors.js';
-import { isRecord } from '../utils.js';
+import { flatMapPair, isRecord, mapRecordValues } from '../utils.js';
 import { transformAST } from './transformations.js';
-import { convertExpression, convertMemberExpression, convertObjectExpression, convertObjectAsExpressionValues, isMagicFunction, throwIfSpread, isMagicFunctionStatmentOnly, } from './expressions.js';
+import { convertExpression, convertMemberExpression, convertObjectExpression, convertObjectAsExpressionValues, isMagicFunction, throwIfSpread, isMagicFunctionStatmentOnly, asExpression, } from './expressions.js';
 import { blockingFunctions } from './generated/functionMetadata.js';
 export function parseStatement(node, ctx, postSteps) {
-    const steps = parseStatementRecursively(node, ctx);
+    const steps = parseStatementRecursively(node, undefined, ctx);
     return transformAST(steps.concat(postSteps ?? []));
 }
-function parseStatementRecursively(node, ctx) {
+function parseStatementRecursively(node, nextNode, ctx) {
     switch (node.type) {
         case AST_NODE_TYPES.BlockStatement:
-            return node.body.flatMap((statement) => parseStatementRecursively(statement, ctx));
+            return flatMapPair(node.body, (statement, nextStatement) => parseStatementRecursively(statement, nextStatement, ctx));
         case AST_NODE_TYPES.VariableDeclaration:
             return convertVariableDeclarations(node.declarations, ctx);
         case AST_NODE_TYPES.ExpressionStatement:
@@ -21,13 +21,13 @@ function parseStatementRecursively(node, ctx) {
                 return assignmentExpressionToSteps(node.expression, ctx);
             }
             else if (node.expression.type === AST_NODE_TYPES.CallExpression) {
-                return [callExpressionToStep(node.expression, undefined, ctx)];
+                return callExpressionToStep(node.expression, undefined, ctx);
             }
             else {
                 return [generalExpressionToAssignStep(node.expression)];
             }
         case AST_NODE_TYPES.ReturnStatement:
-            return [returnStatementToReturnStep(node)];
+            return [returnStatementToReturnStep(node, ctx)];
         case AST_NODE_TYPES.ThrowStatement:
             return [throwStatementToRaiseStep(node)];
         case AST_NODE_TYPES.IfStatement:
@@ -46,8 +46,14 @@ function parseStatementRecursively(node, ctx) {
             return [breakStatementToNextStep(node, ctx)];
         case AST_NODE_TYPES.ContinueStatement:
             return [continueStatementToNextStep(node, ctx)];
-        case AST_NODE_TYPES.TryStatement:
-            return [tryStatementToTryStep(node, ctx)];
+        case AST_NODE_TYPES.TryStatement: {
+            let retryPolicy = undefined;
+            if (nextNode?.type === AST_NODE_TYPES.ExpressionStatement &&
+                nextNode.expression.type === AST_NODE_TYPES.CallExpression) {
+                retryPolicy = parseRetryPolicy(nextNode.expression);
+            }
+            return tryStatementToTrySteps(node, retryPolicy, ctx);
+        }
         case AST_NODE_TYPES.LabeledStatement:
             return labeledStep(node, ctx);
         case AST_NODE_TYPES.EmptyStatement:
@@ -64,7 +70,7 @@ function parseStatementRecursively(node, ctx) {
     }
 }
 function convertVariableDeclarations(declarations, ctx) {
-    return declarations.map((decl) => {
+    return declarations.flatMap((decl) => {
         if (decl.id.type !== AST_NODE_TYPES.Identifier) {
             throw new WorkflowSyntaxError('Expected Identifier', decl.loc);
         }
@@ -82,7 +88,7 @@ function convertVariableDeclarations(declarations, ctx) {
             const value = decl.init == null
                 ? new PrimitiveExpression(null)
                 : convertExpression(decl.init);
-            return new AssignStepAST([[targetName, value]]);
+            return [new AssignStepAST([[targetName, value]])];
         }
     });
 }
@@ -133,7 +139,7 @@ function assignmentExpressionToSteps(node, ctx) {
         const needsTempVariable = compoundOperator === undefined ||
             node.left.type !== AST_NODE_TYPES.Identifier;
         const resultVariable = needsTempVariable ? '__temp' : targetName;
-        steps.push(callExpressionToStep(node.right, resultVariable, ctx));
+        steps.push(...callExpressionToStep(node.right, resultVariable, ctx));
         if (!needsTempVariable) {
             return steps;
         }
@@ -154,20 +160,25 @@ function callExpressionToStep(node, resultVariable, ctx) {
         const calleeName = calleeExpression.toString();
         if (calleeName === 'parallel') {
             // A custom implementation for "parallel"
-            return callExpressionToParallelStep(node, ctx);
+            return [callExpressionToParallelStep(node, ctx)];
         }
         else if (calleeName === 'retry_policy') {
-            return callExpressionToCallStep(calleeName, node.arguments, resultVariable);
+            // retry_policy() is handled by AST_NODE_TYPES.TryStatement and therefore ignored here
+            return [];
         }
         else if (calleeName === 'call_step') {
-            return createCallStep(node.arguments, resultVariable);
+            return [createCallStep(node, node.arguments, resultVariable)];
         }
         else if (blockingFunctions.has(calleeName)) {
             const argumentNames = blockingFunctions.get(calleeName) ?? [];
-            return blockingFunctionCallStep(calleeName, argumentNames, node.arguments, resultVariable);
+            return [
+                blockingFunctionCallStep(calleeName, argumentNames, node.arguments, resultVariable),
+            ];
         }
         else {
-            return callExpressionAssignStep(calleeName, node.arguments, resultVariable);
+            return [
+                callExpressionAssignStep(calleeName, node.arguments, resultVariable),
+            ];
         }
     }
     else {
@@ -183,17 +194,9 @@ function callExpressionAssignStep(functionName, argumentsNode, resultVariable) {
         ],
     ]);
 }
-function callExpressionToCallStep(functionName, argumentsNode, resultVariable) {
-    if (argumentsNode.length < 1 ||
-        argumentsNode[0].type !== AST_NODE_TYPES.ObjectExpression) {
-        throw new WorkflowSyntaxError('Expected one object parameter', argumentsNode[0].loc);
-    }
-    const workflowArguments = convertObjectAsExpressionValues(argumentsNode[0]);
-    return new CallStepAST(functionName, workflowArguments, resultVariable);
-}
-function createCallStep(argumentsNode, resultVariable) {
+function createCallStep(node, argumentsNode, resultVariable) {
     if (argumentsNode.length < 1) {
-        throw new WorkflowSyntaxError('The first argument must be a Function', argumentsNode[0].loc);
+        throw new WorkflowSyntaxError('The first argument must be a Function', node.loc);
     }
     let functionName;
     if (argumentsNode[0].type === AST_NODE_TYPES.Identifier) {
@@ -327,8 +330,13 @@ function parseParallelOptions(node) {
 function generalExpressionToAssignStep(node) {
     return new AssignStepAST([['__temp', convertExpression(node)]]);
 }
-function returnStatementToReturnStep(node) {
+function returnStatementToReturnStep(node, ctx) {
     const value = node.argument ? convertExpression(node.argument) : undefined;
+    if (ctx.finalizerTargets && ctx.finalizerTargets.length > 0) {
+        // If we are in try statement with a finally block, return statements are
+        // replaced by a jump to finally back with a captured return value.
+        return delayedReturnAndJumpToFinalizer(value, ctx);
+    }
     return new ReturnStepAST(value);
 }
 function throwStatementToRaiseStep(node) {
@@ -464,6 +472,11 @@ function doWhileStatementSteps(node, ctx) {
     return steps;
 }
 function breakStatementToNextStep(node, ctx) {
+    if (ctx.finalizerTargets) {
+        // TODO: would need to detect if this breaks out of the try or catch block,
+        // execute the finally block first and then do the break.
+        throw new WorkflowSyntaxError('break is not supported inside a try-finally block', node.loc);
+    }
     let target;
     if (node.label) {
         target = node.label.name;
@@ -477,6 +490,11 @@ function breakStatementToNextStep(node, ctx) {
     return new NextStepAST(target);
 }
 function continueStatementToNextStep(node, ctx) {
+    if (ctx.finalizerTargets) {
+        // TODO: would need to detect if continue breaks out of the try or catch block,
+        // execute the finally block first and then do the continue.
+        throw new WorkflowSyntaxError('continue is not supported inside a try-finally block', node.loc);
+    }
     let target;
     if (node.label) {
         target = node.label.name;
@@ -489,25 +507,129 @@ function continueStatementToNextStep(node, ctx) {
     }
     return new NextStepAST(target);
 }
-function tryStatementToTryStep(node, ctx) {
-    const steps = parseStatement(node.block, ctx);
-    let exceptSteps = [];
+function tryStatementToTrySteps(node, retryPolicy, ctx) {
+    if (!node.finalizer) {
+        // Basic try-catch without a finally block
+        const baseTryStep = parseTryCatchRetry(node, ctx, retryPolicy);
+        return [baseTryStep];
+    }
+    else {
+        // Try-finally is translated to two nested try blocks. The innermost try is
+        // the actual try body with control flow statements (return, in the future
+        // also break/continue) replaced by jumps to the finally block.
+        //
+        // The outer try's catch block saved the exception and continues to the
+        // finally block.
+        //
+        // The nested try blocks are followed by the finally block and a swith for
+        // checking if we need to perform a delayed return/raise.
+        const startOfFinalizer = new JumpTargetAST();
+        const targets = ctx.finalizerTargets ?? [];
+        targets.push(startOfFinalizer.label);
+        ctx = Object.assign({}, ctx, { finalizerTargets: targets });
+        const [conditionVariable, valueVariable] = finalizerVariables(ctx);
+        const innerTry = parseTryCatchRetry(node, ctx, retryPolicy);
+        const outerTry = new TryStepAST([innerTry], finalizerDelayedException('__fin_exc', conditionVariable, valueVariable), undefined, '__fin_exc');
+        // Reset ctx before parsing the finally block because we don't want to
+        // transform returns in finally block in to delayed returns
+        if (ctx.finalizerTargets && ctx.finalizerTargets.length <= 1) {
+            delete ctx.finalizerTargets;
+        }
+        else {
+            ctx.finalizerTargets?.pop();
+        }
+        const finallyBlock = parseStatement(node.finalizer, ctx);
+        return [
+            finalizerInitializer(conditionVariable, valueVariable),
+            outerTry,
+            startOfFinalizer,
+            ...finallyBlock,
+            finalizerFooter(conditionVariable, valueVariable),
+        ];
+    }
+}
+function finalizerVariables(ctx) {
+    const targets = ctx.finalizerTargets ?? [];
+    const nestingLevel = targets.length > 0 ? `${targets.length}` : '';
+    const conditionVariable = `__t2w_finally_condition${nestingLevel}`;
+    const valueVariable = `__t2w_finally_value${nestingLevel}`;
+    return [conditionVariable, valueVariable];
+}
+function parseTryCatchRetry(node, ctx, retryPolicy) {
+    const trySteps = parseStatement(node.block, ctx);
+    let exceptSteps = undefined;
     let errorVariable = undefined;
     if (node.handler) {
         exceptSteps = parseStatement(node.handler.body, ctx);
-        const handlerParam = node.handler.param;
-        if (handlerParam) {
-            if (handlerParam.type !== AST_NODE_TYPES.Identifier) {
-                throw new WorkflowSyntaxError('The error variable must be an identifier', handlerParam.loc);
-            }
-            errorVariable = handlerParam.name;
-        }
+        errorVariable = extractErrorVariableName(node.handler.param);
     }
-    if (node.finalizer !== null) {
-        // TODO
-        throw new WorkflowSyntaxError('finally block not yet supported', node.finalizer.loc);
+    const baseTryStep = new TryStepAST(trySteps, exceptSteps, retryPolicy, errorVariable);
+    return baseTryStep;
+}
+function extractErrorVariableName(param) {
+    if (!param) {
+        return undefined;
+    }
+    if (param.type !== AST_NODE_TYPES.Identifier) {
+        throw new WorkflowSyntaxError('The error variable must be an identifier', param.loc);
     }
-    return new TryStepAST(steps, exceptSteps, undefined, errorVariable);
+    return param.name;
+}
+/**
+ * The shared header for try-finally for initializing the temp variables
+ */
+function finalizerInitializer(conditionVariable, valueVariable) {
+    return new AssignStepAST([
+        [conditionVariable, new PrimitiveExpression(null)],
+        [valueVariable, new PrimitiveExpression(null)],
+    ]);
+}
+/**
+ * The shared footer of a finally block that re-throws the exception or
+ * returns the value returned by the try body.
+ *
+ * The footer code in TypeScript:
+ *
+ * if (__t2w_finally_condition == "return") {
+ *   return __t2w_finally_value
+ * } elseif (__t2w_finally_condition == "raise") {
+ *   throw __t2w_finally_value
+ * }
+ */
+function finalizerFooter(conditionVariable, valueVariable) {
+    return new SwitchStepAST([
+        {
+            condition: new BinaryExpression(new VariableReferenceExpression(conditionVariable), '==', new PrimitiveExpression('return')),
+            steps: [
+                new ReturnStepAST(new VariableReferenceExpression(valueVariable)),
+            ],
+        },
+        {
+            condition: new BinaryExpression(new VariableReferenceExpression(conditionVariable), '==', new PrimitiveExpression('raise')),
+            steps: [new RaiseStepAST(new VariableReferenceExpression(valueVariable))],
+        },
+    ]);
+}
+function finalizerDelayedException(exceptionVariableName, conditionVariableName, valueVariableName) {
+    return [
+        new AssignStepAST([
+            [conditionVariableName, new PrimitiveExpression('raise')],
+            [
+                valueVariableName,
+                new VariableReferenceExpression(exceptionVariableName),
+            ],
+        ]),
+    ];
+}
+function delayedReturnAndJumpToFinalizer(value, ctx) {
+    const finalizerTarget = ctx.finalizerTargets && ctx.finalizerTargets.length > 0
+        ? ctx.finalizerTargets[ctx.finalizerTargets.length - 1]
+        : undefined;
+    const [conditionVariable, valueVariable] = finalizerVariables(ctx);
+    return new AssignStepAST([
+        [conditionVariable, new PrimitiveExpression('return')],
+        [valueVariable, value ?? new PrimitiveExpression(null)],
+    ], finalizerTarget);
 }
 function labeledStep(node, ctx) {
     const steps = parseStatement(node.body, ctx);
@@ -516,3 +638,66 @@ function labeledStep(node, ctx) {
     }
     return steps;
 }
+function parseRetryPolicy(node) {
+    const callee = node.callee;
+    if (callee.type !== AST_NODE_TYPES.Identifier ||
+        callee.name !== 'retry_policy') {
+        // Ignore everything else besides retry_policy()
+        return undefined;
+    }
+    if (node.arguments.length < 1) {
+        throw new WorkflowSyntaxError('Required argument missing', node.loc);
+    }
+    const arg0 = throwIfSpread(node.arguments).map(convertExpression)[0];
+    const argsLoc = node.arguments[0].loc;
+    if (isFullyQualifiedName(arg0)) {
+        return arg0.toString();
+    }
+    else if (arg0.expressionType === 'primitive' && isRecord(arg0.value)) {
+        return retryPolicyFromParams(arg0.value, argsLoc);
+    }
+    else {
+        throw new WorkflowSyntaxError('Unexpected type', argsLoc);
+    }
+}
+function retryPolicyFromParams(paramsObject, argsLoc) {
+    const params = mapRecordValues(paramsObject, asExpression);
+    if ('backoff' in params) {
+        let predicate = '';
+        const predicateEx = params.predicate;
+        if (predicateEx === undefined) {
+            predicate = undefined;
+        }
+        else if (isFullyQualifiedName(predicateEx)) {
+            predicate = predicateEx.toString();
+        }
+        else {
+            throw new WorkflowSyntaxError('"predicate" must be a function name', argsLoc);
+        }
+        const backoffEx = params.backoff;
+        if (backoffEx.expressionType === 'primitive' && isRecord(backoffEx.value)) {
+            const backoffLit = backoffEx.value;
+            return {
+                predicate,
+                maxRetries: params.max_retries,
+                backoff: {
+                    initialDelay: backoffLit.initial_delay
+                        ? asExpression(backoffLit.initial_delay)
+                        : undefined,
+                    maxDelay: backoffLit.max_delay
+                        ? asExpression(backoffLit.max_delay)
+                        : undefined,
+                    multiplier: backoffLit.multiplier
+                        ? asExpression(backoffLit.multiplier)
+                        : undefined,
+                },
+            };
+        }
+        else {
+            throw new WorkflowSyntaxError('Expected an object literal', argsLoc);
+        }
+    }
+    else {
+        throw new WorkflowSyntaxError('Some required retry policy parameters are missing', argsLoc);
+    }
+}

package/dist/transpiler/transformations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/transpiler/transformations.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,eAAe,EAChB,MAAM,iBAAiB,CAAA;AAwBxB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAUxE;AA6JD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EAAE,GACvB,eAAe,EAAE,CAqBnB"}
+{"version":3,"file":"transformations.d.ts","sourceRoot":"","sources":["../../src/transpiler/transformations.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,eAAe,EAChB,MAAM,iBAAiB,CAAA;AAqBxB;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAQxE;AAiCD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EAAE,GACvB,eAAe,EAAE,CAqBnB"}

package/dist/transpiler/transformations.js

@@ -1,7 +1,7 @@
-import { AssignStepAST, CallStepAST, ForStepAST, RaiseStepAST, ReturnStepAST, SwitchStepAST, TryStepAST, } from '../ast/steps.js';
+import { AssignStepAST, CallStepAST, ForStepAST, RaiseStepAST, ReturnStepAST, SwitchStepAST, } from '../ast/steps.js';
 import { InternalTranspilingError } from '../errors.js';
 import { isRecord, mapRecordValues } from '../utils.js';
-import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, expressionToLiteralValueOrLiteralExpression, isExpression, isFullyQualifiedName, isLiteral, } from '../ast/expressions.js';
+import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, isExpression, isLiteral, } from '../ast/expressions.js';
 import { blockingFunctions } from './generated/functionMetadata.js';
 const Unmodified = Symbol();
 /**
@@ -11,7 +11,7 @@ const Unmodified = Symbol();
  * called on each nesting level separately.
  */
 export function transformAST(steps) {
-    return blockingCallsAsCallSteps(runtimeFunctionImplementation(flattenPlainNextConditions(combineRetryBlocksToTry(mergeAssignSteps(mapLiteralsAsAssignSteps(steps))))));
+    return blockingCallsAsCallSteps(runtimeFunctionImplementation(flattenPlainNextConditions(mergeAssignSteps(mapLiteralsAsAssignSteps(steps)))));
 }
 /**
  * Merge consecutive assign steps into one assign step
@@ -35,95 +35,6 @@ function mergeAssignSteps(steps) {
         return acc;
     }, []);
 }
-/**
- * Transform a retry_policy call step to a retry block in a preceeding try step
- */
-function combineRetryBlocksToTry(steps) {
-    return steps.reduce((acc, current) => {
-        const prev = acc.length > 0 ? acc[acc.length - 1] : null;
-        if (current.tag === 'call' && current.call === 'retry_policy') {
-            if (prev?.tag === 'try') {
-                if (prev.retryPolicy) {
-                    throw new InternalTranspilingError('Retry policy already assigned!');
-                }
-                let retryPolicy = undefined;
-                const retryParameters = current.args;
-                if (retryParameters) {
-                    const retryPolicyEx = retryParameters.policy;
-                    if (retryPolicyEx && isFullyQualifiedName(retryPolicyEx)) {
-                        retryPolicy = retryPolicyEx.toString();
-                    }
-                    if (!retryPolicy) {
-                        let predicate = '';
-                        const predicateEx = retryParameters.predicate;
-                        if (predicateEx) {
-                            if (isFullyQualifiedName(predicateEx)) {
-                                predicate = predicateEx.toString();
-                            }
-                            else {
-                                throw new InternalTranspilingError('"predicate" must be a function name');
-                            }
-                        }
-                        const maxRetries = parseRetryPolicyNumber(retryParameters, 'max_retries');
-                        let initialDelay = 1;
-                        let maxDelay = 1;
-                        let multiplier = 1;
-                        const backoffEx = retryParameters.backoff;
-                        if (backoffEx &&
-                            isLiteral(backoffEx) &&
-                            backoffEx.expressionType === 'primitive') {
-                            const backoffLit = backoffEx.value;
-                            if (isRecord(backoffLit)) {
-                                initialDelay = parseRetryPolicyNumber(backoffLit, 'initial_delay');
-                                maxDelay = parseRetryPolicyNumber(backoffLit, 'max_delay');
-                                multiplier = parseRetryPolicyNumber(backoffLit, 'multiplier');
-                            }
-                        }
-                        retryPolicy = {
-                            predicate,
-                            maxRetries,
-                            backoff: {
-                                initialDelay,
-                                maxDelay,
-                                multiplier,
-                            },
-                        };
-                    }
-                }
-                const tryWithRetry = new TryStepAST(prev.trySteps, prev.exceptSteps, retryPolicy, prev.errorMap);
-                acc.pop();
-                acc.push(tryWithRetry);
-            }
-            // If prev is not a try step, "retry_policy" is ignored. Should print a warning.
-        }
-        else {
-            acc.push(current);
-        }
-        return acc;
-    }, []);
-}
-function parseRetryPolicyNumber(record, keyName) {
-    let primitiveValue;
-    const primitiveOrExpression = record[keyName];
-    if (primitiveOrExpression && isExpression(primitiveOrExpression)) {
-        if (isLiteral(primitiveOrExpression)) {
-            primitiveValue = expressionToLiteralValueOrLiteralExpression(primitiveOrExpression);
-        }
-        else {
-            throw new InternalTranspilingError(`Support for non-literal "${keyName}" values not yet implemented`);
-        }
-    }
-    else if (primitiveOrExpression) {
-        primitiveValue = primitiveOrExpression;
-    }
-    else {
-        throw new InternalTranspilingError(`"${keyName}" expected`);
-    }
-    if (typeof primitiveValue !== 'number') {
-        throw new InternalTranspilingError(`"${keyName}" must be a number`);
-    }
-    return primitiveValue;
-}
 /**
  * Merge a next step to the previous step.
  *

package/dist/utils.d.ts

@@ -3,4 +3,11 @@ export declare function isRecord(object: unknown): object is Record<keyof never,
  * Apply f to values of obj and return the result
  */
 export declare function mapRecordValues<T, U>(obj: Record<string, T>, f: (t: T) => U): Record<string, U>;
+/**
+ * Like arr.flatMap() but the callback takes two consecutive array elements.
+ *
+ * During the last execution of the callback, the second argument (which would
+ * be element after the last array element) will be undefined.
+ */
+export declare function flatMapPair<T, U>(arr: T[], callback: (val: T, next: T | undefined) => U[]): U[];
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CACtB,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,OAAO,CAAC,CAExC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACtB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACb,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAEnB"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CACtB,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,OAAO,CAAC,CAExC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACtB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GACb,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAEnB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAC9B,GAAG,EAAE,CAAC,EAAE,EACR,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,EAAE,GAC7C,CAAC,EAAE,CAaL"}

package/dist/utils.js

@@ -7,3 +7,20 @@ export function isRecord(object) {
 export function mapRecordValues(obj, f) {
     return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, f(v)]));
 }
+/**
+ * Like arr.flatMap() but the callback takes two consecutive array elements.
+ *
+ * During the last execution of the callback, the second argument (which would
+ * be element after the last array element) will be undefined.
+ */
+export function flatMapPair(arr, callback) {
+    if (arr.length <= 0) {
+        return [];
+    }
+    const mapped = [];
+    for (let i = 0; i < arr.length - 1; i++) {
+        mapped.push(...callback(arr[i], arr[i + 1]));
+    }
+    mapped.push(...callback(arr[arr.length - 1], undefined));
+    return mapped;
+}