ts2workflows 0.3.0 → 0.4.0

package/dist/transpiler/index.js

@@ -1,67 +1,68 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument */
-import * as parser from '@typescript-eslint/typescript-estree';
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { parse, AST_NODE_TYPES, } from '@typescript-eslint/typescript-estree';
 import * as YAML from 'yaml';
 import { SubworkflowAST } from '../ast/steps.js';
 import { WorkflowSyntaxError } from '../errors.js';
 import { generateStepNames } from '../ast/stepnames.js';
-import { assertType } from './asserts.js';
-import { parseBlockStatement } from './statements.js';
-const { AssignmentPattern, ExportNamedDeclaration, FunctionDeclaration, Identifier, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, Literal, Program, TSDeclareFunction, TSTypeAliasDeclaration, TSInterfaceDeclaration, } = AST_NODE_TYPES;
+import { parseStatement } from './statements.js';
 export function transpile(code) {
     const parserOptions = {
         jsDocParsingMode: 'none',
         loc: true,
         range: false,
     };
-    const ast = parser.parse(code, parserOptions);
-    assertType(ast, Program);
+    const ast = parse(code, parserOptions);
     const workflowAst = { subworkflows: ast.body.flatMap(parseTopLevelStatement) };
     const workflow = generateStepNames(workflowAst);
     return YAML.stringify(workflow.render(), { lineWidth: 100 });
 }
 function parseTopLevelStatement(node) {
-    switch (node?.type) {
-        case FunctionDeclaration:
+    switch (node.type) {
+        case AST_NODE_TYPES.FunctionDeclaration:
             return [parseSubworkflows(node)];
-        case ImportDeclaration:
-            if (node.specifiers.some((spec) => spec.type === ImportNamespaceSpecifier ||
-                spec.type === ImportDefaultSpecifier)) {
+        case AST_NODE_TYPES.ImportDeclaration:
+            if (node.specifiers.some((spec) => spec.type === AST_NODE_TYPES.ImportNamespaceSpecifier ||
+                spec.type === AST_NODE_TYPES.ImportDefaultSpecifier)) {
                 throw new WorkflowSyntaxError('Only named imports are allowed', node.loc);
             }
             return [];
-        case ExportNamedDeclaration:
+        case AST_NODE_TYPES.ExportNamedDeclaration:
             // "export" keyword is ignored, but a possible function declaration is transpiled.
-            if (node?.declaration) {
+            if (node.declaration?.type === AST_NODE_TYPES.FunctionDeclaration &&
+                node.declaration.id?.type === AST_NODE_TYPES.Identifier) {
+                // Why is "as" needed here?
                 return parseTopLevelStatement(node.declaration);
             }
             else {
                 return [];
             }
-        case TSInterfaceDeclaration:
-        case TSTypeAliasDeclaration:
-        case TSDeclareFunction:
+        case AST_NODE_TYPES.TSInterfaceDeclaration:
+        case AST_NODE_TYPES.TSTypeAliasDeclaration:
+        case AST_NODE_TYPES.TSDeclareFunction:
             // Ignore "type", "interface" and "declare function" at the top-level
             return [];
         default:
-            throw new WorkflowSyntaxError(`Only function definitions, imports and type aliases allowed at the top level, encountered ${node?.type}`, node?.loc);
+            throw new WorkflowSyntaxError(`Only function definitions, imports and type aliases allowed at the top level, encountered ${node.type}`, node.loc);
     }
 }
 function parseSubworkflows(node) {
-    assertType(node, FunctionDeclaration);
-    if (node.id.type !== Identifier) {
-        throw new WorkflowSyntaxError('Expected Identifier as a function name', node.id.loc);
-    }
     const nodeParams = node.params;
     const workflowParams = nodeParams.map((param) => {
         switch (param.type) {
-            case Identifier:
+            case AST_NODE_TYPES.Identifier:
                 return { name: param.name };
-            case AssignmentPattern:
-                assertType(param.left, Identifier);
-                if (param.right.type !== Literal) {
+            case AST_NODE_TYPES.AssignmentPattern:
+                if (param.left.type !== AST_NODE_TYPES.Identifier) {
+                    throw new WorkflowSyntaxError('The default value must be an identifier', param.left.loc);
+                }
+                if (param.right.type !== AST_NODE_TYPES.Literal) {
                     throw new WorkflowSyntaxError('The default value must be a literal', param.right.loc);
                 }
+                if (!(typeof param.right.value === 'string' ||
+                    typeof param.right.value === 'number' ||
+                    typeof param.right.value === 'boolean' ||
+                    param.right.value === null)) {
+                    throw new WorkflowSyntaxError('The default value must be a string, number, boolean or null', param.left.loc);
+                }
                 return {
                     name: param.left.name,
                     default: param.right.value,
@@ -70,6 +71,6 @@ function parseSubworkflows(node) {
                 throw new WorkflowSyntaxError('Function parameter must be an identifier or an assignment', param.loc);
         }
     });
-    const steps = parseBlockStatement(node.body, {});
+    const steps = parseStatement(node.body, {});
     return new SubworkflowAST(node.id.name, steps, workflowParams);
 }

package/dist/transpiler/statements.d.ts

@@ -1,7 +1,8 @@
+import { TSESTree } from '@typescript-eslint/typescript-estree';
 import { StepName, WorkflowStepAST } from '../ast/steps.js';
 export interface ParsingContext {
     breakTarget?: StepName;
     continueTarget?: StepName;
 }
-export declare function parseBlockStatement(node: any, ctx: ParsingContext): WorkflowStepAST[];
+export declare function parseStatement(node: TSESTree.Statement, ctx: ParsingContext, postSteps?: WorkflowStepAST[]): 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":"AAEA,OAAO,EASL,QAAQ,EAMR,eAAe,EAEhB,MAAM,iBAAiB,CAAA;AAyDxB,MAAM,WAAW,cAAc;IAE7B,WAAW,CAAC,EAAE,QAAQ,CAAA;IAEtB,cAAc,CAAC,EAAE,QAAQ,CAAA;CAC1B;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,GAAG,EACT,GAAG,EAAE,cAAc,GAClB,eAAe,EAAE,CAKnB"}
+{"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,EASL,QAAQ,EAMR,eAAe,EAChB,MAAM,iBAAiB,CAAA;AA0BxB,MAAM,WAAW,cAAc;IAE7B,WAAW,CAAC,EAAE,QAAQ,CAAA;IAEtB,cAAc,CAAC,EAAE,QAAQ,CAAA;CAC1B;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,SAAS,EACxB,GAAG,EAAE,cAAc,EACnB,SAAS,CAAC,EAAE,eAAe,EAAE,GAC5B,eAAe,EAAE,CAGnB"}