ts2workflows 0.10.0 → 0.12.0

package/dist/transpiler/{expressions.js → parseexpressions.js}

@@ -1,29 +1,39 @@
-import * as R from 'ramda';
-import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
-import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, asExpression, isFullyQualifiedName, nullEx, } from '../ast/expressions.js';
+import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
+import { binaryEx, booleanEx, expressionToString, functionInvocationEx, isQualifiedName, listEx, mapEx, memberEx, nullEx, numberEx, stringEx, unaryEx, variableReferenceEx, } from '../ast/expressions.js';
 import { InternalTranspilingError, WorkflowSyntaxError } from '../errors.js';
 export function convertExpression(instance) {
     switch (instance.type) {
         case AST_NODE_TYPES.ArrayExpression:
-            return asExpression(convertArrayExpression(instance));
+            return convertArrayExpression(instance);
         case AST_NODE_TYPES.ObjectExpression:
-            return asExpression(convertObjectExpression(instance));
+            return convertObjectExpression(instance);
         case AST_NODE_TYPES.Literal:
             if (instance.value instanceof RegExp) {
                 throw new WorkflowSyntaxError('RegExp is not supported', instance.loc);
             }
-            if (typeof instance.value === 'bigint') {
+            else if (typeof instance.value === 'bigint') {
                 throw new WorkflowSyntaxError('BigInt is not supported', instance.loc);
             }
-            return new PrimitiveExpression(instance.value);
+            else if (typeof instance.value === 'string') {
+                return stringEx(instance.value);
+            }
+            else if (typeof instance.value === 'number') {
+                return numberEx(instance.value);
+            }
+            else if (typeof instance.value === 'boolean') {
+                return booleanEx(instance.value);
+            }
+            else {
+                return nullEx;
+            }
         case AST_NODE_TYPES.TemplateLiteral:
             return convertTemplateLiteralToExpression(instance);
         case AST_NODE_TYPES.Identifier:
-            if (instance.name === 'null' || instance.name === 'undefined') {
+            if (instance.name === 'undefined') {
                 return nullEx;
             }
             else {
-                return new VariableReferenceExpression(instance.name);
+                return variableReferenceEx(instance.name);
             }
         case AST_NODE_TYPES.UnaryExpression:
             return convertUnaryExpression(instance);
@@ -39,56 +49,38 @@ export function convertExpression(instance) {
         case AST_NODE_TYPES.ConditionalExpression:
             return convertConditionalExpression(instance);
         case AST_NODE_TYPES.TSAsExpression:
-            return convertExpression(instance.expression);
         case AST_NODE_TYPES.TSNonNullExpression:
+        case AST_NODE_TYPES.TSInstantiationExpression:
+        case AST_NODE_TYPES.TSSatisfiesExpression:
             return convertExpression(instance.expression);
         case AST_NODE_TYPES.AwaitExpression:
             return convertExpression(instance.argument);
-        case AST_NODE_TYPES.TSInstantiationExpression:
-            return convertExpression(instance.expression);
         default:
             throw new WorkflowSyntaxError(`Not implemented expression type: ${instance.type}`, instance.loc);
     }
 }
-function convertExpressionOrPrimitive(instance) {
-    const ex = convertExpression(instance);
-    if (ex.expressionType === 'primitive') {
-        return ex.value;
-    }
-    else {
-        return ex;
-    }
-}
 export function convertObjectExpression(node) {
-    return Object.fromEntries(throwIfSpread(node.properties).map(({ key, value }) => {
+    return mapEx(Object.fromEntries(throwIfSpread(node.properties).map(({ key, value }) => {
         let keyPrimitive;
         if (key.type === AST_NODE_TYPES.Identifier) {
             keyPrimitive = key.name;
         }
-        else if (key.type === AST_NODE_TYPES.Literal) {
-            if (typeof key.value === 'string') {
-                keyPrimitive = key.value;
-            }
-            else {
-                throw new WorkflowSyntaxError(`Map keys must be identifiers or strings, encountered: ${typeof key.value}`, key.loc);
-            }
+        else if (key.type === AST_NODE_TYPES.Literal &&
+            typeof key.value === 'string') {
+            keyPrimitive = key.value;
         }
         else {
-            throw new WorkflowSyntaxError(`Not implemented object key type: ${key.type}`, key.loc);
+            throw new WorkflowSyntaxError(`Map keys must be identifiers or strings, encountered: ${key.type}`, key.loc);
         }
         if (value.type === AST_NODE_TYPES.AssignmentPattern ||
             value.type === AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
             throw new WorkflowSyntaxError('Value not supported', value.loc);
         }
-        return [keyPrimitive, convertExpressionOrPrimitive(value)];
-    }));
-}
-export function convertObjectAsExpressionValues(node) {
-    // Convert Primitive values to PrimitiveExpressions
-    return R.map(asExpression, convertObjectExpression(node));
+        return [keyPrimitive, convertExpression(value)];
+    })));
 }
 function convertArrayExpression(instance) {
-    return throwIfSpread(instance.elements).map((e) => e === null ? nullEx : convertExpressionOrPrimitive(e));
+    return listEx(throwIfSpread(instance.elements).map((e) => e === null ? nullEx : convertExpression(e)));
 }
 function convertBinaryExpression(instance) {
     // Special case for nullish coalescing because the result is a function call
@@ -127,19 +119,16 @@ function convertBinaryExpression(instance) {
         default:
             throw new WorkflowSyntaxError(`Unsupported binary operator: ${instance.operator}`, instance.loc);
     }
-    if (instance.left.type === AST_NODE_TYPES.PrivateIdentifier) {
-        throw new WorkflowSyntaxError('Private identifier not supported', instance.left.loc);
-    }
-    return new BinaryExpression(convertExpression(instance.left), op, convertExpression(instance.right));
+    return binaryEx(convertExpression(throwIfPrivateIdentifier(instance.left)), op, convertExpression(instance.right));
 }
 function nullishCoalescingExpression(left, right) {
-    return new FunctionInvocationExpression('default', [
+    return functionInvocationEx('default', [
         convertExpression(left),
         convertExpression(right),
     ]);
 }
 function convertUnaryExpression(instance) {
-    if (instance.prefix === false) {
+    if (!instance.prefix) {
         throw new WorkflowSyntaxError('only prefix unary operators are supported', instance.loc);
     }
     let op;
@@ -163,9 +152,6 @@ function convertUnaryExpression(instance) {
             op = undefined;
             istypeof = true;
             break;
-        case undefined:
-            op = undefined;
-            break;
         default:
             throw new WorkflowSyntaxError(`Unsupported unary operator: ${instance.operator}`, instance.loc);
     }
@@ -174,7 +160,7 @@ function convertUnaryExpression(instance) {
         return convertTypeOfExpression(ex);
     }
     else if (op) {
-        return new UnaryExpression(op, ex);
+        return unaryEx(op, ex);
     }
     else {
         return ex;
@@ -182,55 +168,54 @@ function convertUnaryExpression(instance) {
 }
 function convertTypeOfExpression(value) {
     // Note for future refactoring: evalute value only once (in case it has side effects)
-    return new FunctionInvocationExpression('text.replace_all_regex', [
-        new FunctionInvocationExpression('text.replace_all_regex', [
-            new FunctionInvocationExpression('get_type', [value]),
-            new PrimitiveExpression('^(bytes|list|map|null)$'),
-            new PrimitiveExpression('object'),
+    return functionInvocationEx('text.replace_all_regex', [
+        functionInvocationEx('text.replace_all_regex', [
+            functionInvocationEx('get_type', [value]),
+            stringEx('^(bytes|list|map|null)$'),
+            stringEx('object'),
         ]),
-        new PrimitiveExpression('^(double|integer)$'),
-        new PrimitiveExpression('number'),
+        stringEx('^(double|integer)$'),
+        stringEx('number'),
     ]);
 }
 export function convertMemberExpression(node) {
-    if (node.property.type === AST_NODE_TYPES.PrivateIdentifier) {
-        throw new WorkflowSyntaxError('Private identifier not supported', node.property.loc);
-    }
     const object = convertExpression(node.object);
-    return new MemberExpression(object, convertExpression(node.property), node.computed);
+    return memberEx(object, convertExpression(throwIfPrivateIdentifier(node.property)), node.computed);
 }
 function convertChainExpression(node) {
     const properties = chainExpressionToFlatArray(node.expression);
     const args = optionalChainToMapGetArguments(properties);
-    return new FunctionInvocationExpression('map.get', args);
+    return functionInvocationEx('map.get', args);
 }
 function chainExpressionToFlatArray(node) {
-    if (node.type === AST_NODE_TYPES.MemberExpression) {
-        if (node.property.type === AST_NODE_TYPES.PrivateIdentifier) {
-            throw new WorkflowSyntaxError('Private identifier not supported', node.property.loc);
+    switch (node.type) {
+        case TSESTree.AST_NODE_TYPES.Identifier:
+        case TSESTree.AST_NODE_TYPES.ChainExpression:
+            return [
+                {
+                    property: node,
+                    optional: false,
+                    computed: false,
+                },
+            ];
+        case TSESTree.AST_NODE_TYPES.MemberExpression: {
+            const data = {
+                property: throwIfPrivateIdentifier(node.property),
+                optional: node.optional,
+                computed: node.computed,
+            };
+            return chainExpressionToFlatArray(node.object).concat([data]);
         }
-        const data = {
-            property: node.property,
-            optional: node.optional,
-            computed: node.computed,
-        };
-        return chainExpressionToFlatArray(node.object).concat([data]);
-    }
-    else {
-        return [
-            {
-                property: node,
-                optional: false,
-                computed: false,
-            },
-        ];
+        case AST_NODE_TYPES.TSAsExpression:
+        case AST_NODE_TYPES.TSNonNullExpression:
+        case AST_NODE_TYPES.TSInstantiationExpression:
+        case AST_NODE_TYPES.TSSatisfiesExpression:
+            return chainExpressionToFlatArray(node.expression);
+        default:
+            throw new WorkflowSyntaxError(`Type ${node.type} is not supported in optional chaining`, node.loc);
     }
 }
 function optionalChainToMapGetArguments(properties) {
-    if (properties.length <= 0) {
-        // this shouldn't happen
-        return [];
-    }
     let base;
     let optionalSliceStart;
     const firstOptional = properties.findIndex((p) => p.optional);
@@ -253,8 +238,8 @@ function optionalChainToMapGetArguments(properties) {
         if (opt.computed) {
             return propertyExp;
         }
-        else if (isFullyQualifiedName(propertyExp)) {
-            return new PrimitiveExpression(propertyExp.toString());
+        else if (isQualifiedName(propertyExp)) {
+            return stringEx(expressionToString(propertyExp));
         }
         else {
             throw new WorkflowSyntaxError('Unexpected property in an optional chain', opt.property.loc);
@@ -262,7 +247,7 @@ function optionalChainToMapGetArguments(properties) {
     });
     const args = [base];
     if (optionals.length > 1) {
-        args.push(new PrimitiveExpression(optionals));
+        args.push(listEx(optionals));
     }
     else if (optionals.length === 1) {
         args.push(optionals[0]);
@@ -271,10 +256,10 @@ function optionalChainToMapGetArguments(properties) {
 }
 function memberExpressionFromList(properties) {
     if (properties.length >= 2) {
-        const base = new MemberExpression(convertExpression(properties[0].property), convertExpression(properties[1].property), properties[1].computed);
+        const base = memberEx(convertExpression(properties[0].property), convertExpression(properties[1].property), properties[1].computed);
         return properties
             .slice(2)
-            .reduce((exp, current) => new MemberExpression(exp, convertExpression(current.property), current.computed), base);
+            .reduce((exp, current) => memberEx(exp, convertExpression(current.property), current.computed), base);
     }
     else if (properties.length === 1) {
         return convertExpression(properties[0].property);
@@ -288,8 +273,8 @@ function convertCallExpression(node) {
         throw new WorkflowSyntaxError('Optional call expressions are not supported', node.loc);
     }
     const calleeExpression = convertExpression(node.callee);
-    if (isFullyQualifiedName(calleeExpression)) {
-        const calleeName = calleeExpression.toString();
+    if (isQualifiedName(calleeExpression)) {
+        const calleeName = expressionToString(calleeExpression);
         if (isIntrinsic(calleeName)) {
             let msg;
             if (calleeName === 'call_step') {
@@ -302,7 +287,7 @@ function convertCallExpression(node) {
             throw new WorkflowSyntaxError(msg, node.callee.loc);
         }
         const argumentExpressions = throwIfSpread(node.arguments).map(convertExpression);
-        return new FunctionInvocationExpression(calleeName, argumentExpressions);
+        return functionInvocationEx(calleeName, argumentExpressions);
     }
     else {
         throw new WorkflowSyntaxError('Callee should be a qualified name', node.loc);
@@ -312,7 +297,7 @@ export function isIntrinsic(calleeName) {
     const intrinsics = ['parallel', 'retry_policy', 'call_step'];
     return intrinsics.includes(calleeName);
 }
-export function isIntrinsicStatment(calleeName) {
+export function isIntrinsicStatement(calleeName) {
     const statementNames = ['parallel', 'retry_policy'];
     return statementNames.includes(calleeName);
 }
@@ -320,18 +305,15 @@ function convertConditionalExpression(node) {
     const test = convertExpression(node.test);
     const consequent = convertExpression(node.consequent);
     const alternate = convertExpression(node.alternate);
-    return new FunctionInvocationExpression('if', [test, consequent, alternate]);
+    return functionInvocationEx('if', [test, consequent, alternate]);
 }
 function convertTemplateLiteralToExpression(node) {
     const stringTerms = node.quasis
         .map((x) => x.value.cooked)
-        .map((x) => new PrimitiveExpression(x));
+        .map((x) => stringEx(x));
     const templateTerms = node.expressions
         .map(convertExpression)
-        .map((ex) => new FunctionInvocationExpression('default', [
-        ex,
-        new PrimitiveExpression('null'),
-    ]));
+        .map((ex) => functionInvocationEx('default', [ex, stringEx('null')]));
     // interleave string parts and the expression parts starting with strings
     const interleavedTerms = stringTerms
         .slice(0, stringTerms.length - 1)
@@ -346,10 +328,10 @@ function convertTemplateLiteralToExpression(node) {
         interleavedTerms.push(stringTerms[stringTerms.length - 1]);
     }
     if (interleavedTerms.length === 0) {
-        return new PrimitiveExpression('');
+        return stringEx('');
     }
     else {
-        return interleavedTerms.reduce((previous, current) => new BinaryExpression(previous, '+', current));
+        return interleavedTerms.reduce((previous, current) => binaryEx(previous, '+', current));
     }
 }
 export function throwIfSpread(nodes) {
@@ -360,11 +342,16 @@ export function throwIfSpread(nodes) {
     const argumentExpressions = nodes.filter((x) => x?.type !== AST_NODE_TYPES.SpreadElement);
     return argumentExpressions;
 }
-export function convertVariableNameExpression(instance) {
-    const ex = convertExpression(instance);
-    if (ex.expressionType !== 'variableReference' &&
-        ex.expressionType !== 'member') {
-        throw new WorkflowSyntaxError('The left-hand side of an assignment must be a variable or member expression', instance.loc);
+export function throwIfPrivateIdentifier(prop) {
+    if (prop.type === AST_NODE_TYPES.PrivateIdentifier) {
+        throw new WorkflowSyntaxError('Private identifier not supported', prop.loc);
+    }
+    return prop;
+}
+export function convertAssignmentTarget(node) {
+    const ex = convertExpression(node);
+    if (ex.tag !== 'variableReference' && ex.tag !== 'member') {
+        throw new WorkflowSyntaxError('An assignment taget must be an identifer or a member expression', node.loc);
     }
     return ex;
 }

package/dist/transpiler/parsestatement.d.ts

@@ -0,0 +1,7 @@
+import { TSESTree } from '@typescript-eslint/typescript-estree';
+import { WorkflowStatement } from '../ast/statements.js';
+export interface ParsingContext {
+    readonly parallelNestingLevel?: number;
+}
+export declare function parseStatement(node: TSESTree.Statement, ctx: ParsingContext): WorkflowStatement[];
+//# sourceMappingURL=parsestatement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parsestatement.d.ts","sourceRoot":"","sources":["../../src/transpiler/parsestatement.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,QAAQ,EAAE,MAAM,sCAAsC,CAAA;AAoB/E,OAAO,EAiBL,iBAAiB,EAMlB,MAAM,sBAAsB,CAAA;AAa7B,MAAM,WAAW,cAAc;IAG7B,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;CACvC;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,GAAG,EAAE,cAAc,GAClB,iBAAiB,EAAE,CAiFrB"}