ts2workflows 0.8.0 → 0.9.0

package/dist/transpiler/expressions.js

@@ -1,69 +1,26 @@
+import * as R from 'ramda';
 import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
-import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, isExpression, isFullyQualifiedName, } from '../ast/expressions.js';
+import { BinaryExpression, FunctionInvocationExpression, MemberExpression, PrimitiveExpression, UnaryExpression, VariableReferenceExpression, asExpression, isFullyQualifiedName, nullEx, } from '../ast/expressions.js';
 import { InternalTranspilingError, WorkflowSyntaxError } from '../errors.js';
-import { mapRecordValues } from '../utils.js';
 export function convertExpression(instance) {
-    const expOrPrimitive = convertExpressionOrPrimitive(instance);
-    if (isExpression(expOrPrimitive)) {
-        return expOrPrimitive;
-    }
-    else {
-        return new PrimitiveExpression(expOrPrimitive);
-    }
-}
-export function convertObjectExpression(node) {
-    return 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 {
-            throw new WorkflowSyntaxError(`Not implemented object key type: ${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 mapRecordValues(convertObjectExpression(node), asExpression);
-}
-function convertExpressionOrPrimitive(instance) {
     switch (instance.type) {
         case AST_NODE_TYPES.ArrayExpression:
-            return convertArrayExpression(instance);
+            return asExpression(convertArrayExpression(instance));
         case AST_NODE_TYPES.ObjectExpression:
-            return convertObjectExpression(instance);
+            return asExpression(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') {
-                throw new WorkflowSyntaxError('BigInt in not supported', instance.loc);
+                throw new WorkflowSyntaxError('BigInt is not supported', instance.loc);
             }
-            return instance.value;
+            return new PrimitiveExpression(instance.value);
         case AST_NODE_TYPES.TemplateLiteral:
             return convertTemplateLiteralToExpression(instance);
         case AST_NODE_TYPES.Identifier:
             if (instance.name === 'null' || instance.name === 'undefined') {
-                return null;
-            }
-            else if (instance.name === 'True' || instance.name === 'TRUE') {
-                return true;
-            }
-            else if (instance.name === 'False' || instance.name === 'FALSE') {
-                return false;
+                return nullEx;
             }
             else {
                 return new VariableReferenceExpression(instance.name);
@@ -82,24 +39,59 @@ function convertExpressionOrPrimitive(instance) {
         case AST_NODE_TYPES.ConditionalExpression:
             return convertConditionalExpression(instance);
         case AST_NODE_TYPES.TSAsExpression:
-            return convertExpressionOrPrimitive(instance.expression);
+            return convertExpression(instance.expression);
         case AST_NODE_TYPES.TSNonNullExpression:
-            return convertExpressionOrPrimitive(instance.expression);
+            return convertExpression(instance.expression);
         case AST_NODE_TYPES.AwaitExpression:
-            return convertExpressionOrPrimitive(instance.argument);
+            return convertExpression(instance.argument);
         case AST_NODE_TYPES.TSInstantiationExpression:
-            return convertExpressionOrPrimitive(instance.expression);
+            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 }) => {
+        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 {
+            throw new WorkflowSyntaxError(`Not implemented object key type: ${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));
+}
 function convertArrayExpression(instance) {
-    return throwIfSpread(instance.elements).map((e) => e === null
-        ? new PrimitiveExpression(null)
-        : convertExpressionOrPrimitive(e));
+    return throwIfSpread(instance.elements).map((e) => e === null ? nullEx : convertExpressionOrPrimitive(e));
 }
 function convertBinaryExpression(instance) {
-    // Special case for nullish coalescing becuase the result is a function call
+    // Special case for nullish coalescing because the result is a function call
     // expression, not a binary expression
     if (instance.operator === '??') {
         return nullishCoalescingExpression(instance.left, instance.right);
@@ -189,7 +181,7 @@ function convertUnaryExpression(instance) {
     }
 }
 function convertTypeOfExpression(value) {
-    // Note for future rectoring: evalute value only once (in case it has side effects)
+    // 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]),
@@ -368,6 +360,3 @@ export function throwIfSpread(nodes) {
     const argumentExpressions = nodes.filter((x) => x?.type !== AST_NODE_TYPES.SpreadElement);
     return argumentExpressions;
 }
-export function asExpression(x) {
-    return isExpression(x) ? x : new PrimitiveExpression(x);
-}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transpiler/index.ts"],"names":[],"mappings":"AAaA,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAkBR"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transpiler/index.ts"],"names":[],"mappings":"AAcA,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,MAAM,EAClB,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAkBR"}

package/dist/transpiler/index.js

@@ -4,6 +4,7 @@ import { SubworkflowAST } from '../ast/steps.js';
 import { WorkflowSyntaxError } from '../errors.js';
 import { generateStepNames } from '../ast/stepnames.js';
 import { parseStatement } from './statements.js';
+import { transformAST } from './transformations.js';
 export function transpile(code, inputFile, tsconfigPath) {
     const parserOptions = {
         jsDocParsingMode: 'none',
@@ -51,8 +52,12 @@ function parseTopLevelStatement(node) {
     }
 }
 function parseSubworkflows(node) {
-    const nodeParams = node.params;
-    const workflowParams = nodeParams.map((param) => {
+    const workflowParams = parseWorkflowParams(node.params);
+    const steps = transformAST(parseStatement(node.body, {}));
+    return new SubworkflowAST(node.id.name, steps, workflowParams);
+}
+function parseWorkflowParams(nodeParams) {
+    return nodeParams.map((param) => {
         switch (param.type) {
             case AST_NODE_TYPES.Identifier:
                 if (param.optional) {
@@ -67,8 +72,6 @@ function parseSubworkflows(node) {
                 throw new WorkflowSyntaxError('Function parameter must be an identifier or an assignment', param.loc);
         }
     });
-    const steps = parseStatement(node.body, {});
-    return new SubworkflowAST(node.id.name, steps, workflowParams);
 }
 function parseSubworkflowDefaultArgument(param) {
     if (param.left.type !== AST_NODE_TYPES.Identifier) {

package/dist/transpiler/statements.d.ts

@@ -1,9 +1,10 @@
 import { TSESTree } from '@typescript-eslint/typescript-estree';
 import { StepName, WorkflowStepAST } from '../ast/steps.js';
 export interface ParsingContext {
-    breakTarget?: StepName;
-    continueTarget?: StepName;
+    readonly breakTarget?: StepName;
+    readonly continueTarget?: StepName;
+    readonly parallelNestingLevel?: number;
     finalizerTargets?: StepName[];
 }
-export declare function parseStatement(node: TSESTree.Statement, ctx: ParsingContext, postSteps?: WorkflowStepAST[]): WorkflowStepAST[];
+export declare function parseStatement(node: TSESTree.Statement, ctx: ParsingContext): WorkflowStepAST[];
 //# sourceMappingURL=statements.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../src/transpiler/statements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,QAAQ,EAAE,MAAM,sCAAsC,CAAA;AAC/E,OAAO,EAUL,QAAQ,EAMR,eAAe,EAChB,MAAM,iBAAiB,CAAA;AA6BxB,MAAM,WAAW,cAAc;IAE7B,WAAW,CAAC,EAAE,QAAQ,CAAA;IAEtB,cAAc,CAAC,EAAE,QAAQ,CAAA;IAKzB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,CAAA;CAC9B;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,GAAG,EAAE,cAAc,EACnB,SAAS,CAAC,EAAE,eAAe,EAAE,GAC5B,eAAe,EAAE,CAGnB"}
+{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../src/transpiler/statements.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,QAAQ,EAAE,MAAM,sCAAsC,CAAA;AAC/E,OAAO,EAWL,QAAQ,EAOR,eAAe,EAChB,MAAM,iBAAiB,CAAA;AAiCxB,MAAM,WAAW,cAAc;IAE7B,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAA;IAE/B,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAA;IAGlC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAKtC,gBAAgB,CAAC,EAAE,QAAQ,EAAE,CAAA;CAC9B;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,GAAG,EAAE,cAAc,GAClB,eAAe,EAAE,CAEnB"}