bio-dts 0.4.1 → 0.6.0

package/lib/post-transform.js

@@ -82,23 +82,50 @@ export default function transform(src) {
     }));
   }
 
+
+  /**
+   * Ensure optional args methods are properly escaped
+   *
+   * @param {import('./util.js').Path} nodePath
+   *
+   * @return {any[]} replacements
+   */
   function fixOptionalArgsMethods(nodePath) {
 
     const {
       value: node
     } = nodePath;
 
-    if (node.type !== 'TSDeclareMethod' && node.type !== 'TSDeclareFunction') {
+    const fnDeclaration = (
+      node.type === 'TSDeclareMethod' ||
+      node.type === 'TSDeclareFunction'
+    );
+
+    const fnDefinition = (
+      node?.typeAnnotation?.typeAnnotation?.type === 'TSFunctionType'
+    );
+
+    if (!fnDeclaration && !fnDefinition) {
       return;
     }
 
-    const hostPath = nodePath.parentPath.value.type === 'ExportNamedDeclaration'
-      ? nodePath.parentPath
-      : nodePath;
+    const params = fnDeclaration
+      ? node.params
+      : node?.typeAnnotation?.typeAnnotation?.parameters;
+
+    const returnType = fnDeclaration
+      ? node.returnType
+      : node?.typeAnnotation?.typeAnnotation?.typeAnnotation;
+
+    const hostPath = (
+      [ 'ExportDefaultDeclaration', 'ExportNamedDeclaration' ].includes(nodePath.parentPath.value.type)
+        ? nodePath.parentPath
+        : nodePath
+    );
 
     const {
       variations
-    } = node.params.slice().reverse().reduce((res, param) => {
+    } = params.slice().reverse().reduce((res, param) => {
 
       let {
         required,
@@ -160,26 +187,37 @@ export default function transform(src) {
     const replacements = variations.slice().reverse().map(variation => {
 
       const builder = {
+        'ClassProperty': b.tsDeclareMethod,
         'TSDeclareFunction': b.tsDeclareFunction,
         'TSDeclareMethod': b.tsDeclareMethod
       }[node.type];
 
+      const hostBuilder = {
+        'ExportNamedDeclaration': b.exportNamedDeclaration,
+        'ExportDefaultDeclaration': b.exportDefaultDeclaration
+      }[hostPath.value.type];
+
       const variationComments = commentPath.value ? [ keepCommentParams(commentPath, variation) ] : [ ];
 
       const newNode = builder.from({
-        ...node,
+        key: node.key,
         params: variation.slice().reverse(),
+        id: node.id,
+        declare: node.declare || false,
+        returnType: b.tsTypeAnnotation.from({
+          ...returnType
+        }),
         comments: hostPath === nodePath ? variationComments : []
       });
 
       return (
-        hostPath === nodePath
-          ? newNode
-          : b.exportNamedDeclaration.from({
+        hostBuilder
+          ? hostBuilder.from({
             ...hostPath.value,
             declaration: newNode,
             comments: variationComments
           })
+          : newNode
       );
     });
 
@@ -274,7 +312,13 @@ export default function transform(src) {
   });
 
   for (const [ path, args ] of replacements) {
-    path.replace(...args);
+    try {
+      path.replace(...args);
+    } catch (err) {
+      console.error('Failed to replace path', path, ...args);
+
+      throw err;
+    }
   }
 
   return print(ast).code;

package/lib/pre-transform.js

@@ -38,19 +38,33 @@ function clazzDefinition(cls, ctor) {
 
   const members = [
     ctor,
-    ...cls.members.filter(
-      m => m.member.type === 'FunctionExpression'
-    ).map(m => {
+    ...cls.members.filter(m => m.source === 'prototype').map(m => {
+
+      // class method
+      if (m.member.type === 'FunctionExpression') {
+        return {
+          'type': 'ClassMethod',
+          'static': false,
+          'key': {
+            'type': 'Identifier',
+            'name': m.name
+          },
+          'kind': 'method',
+          'params': m.member.params,
+          'body': m.member.body,
+          'comments': m.comments
+        };
+      }
+
+      // save to transform into class property
       return {
-        'type': 'ClassMethod',
+        'type': 'ClassProperty',
         'static': false,
         'key': {
           'type': 'Identifier',
           'name': m.name
         },
-        'kind': 'method',
-        'params': m.member.params,
-        'body': m.member.body,
+        'value': m.member,
         'comments': m.comments
       };
     })
@@ -153,8 +167,8 @@ export default function transform(src) {
   // query
   for (const cls of classes) {
     cls.members = [
-      ...findEmbeddedMethods(cls),
-      ...findProtoMethods(cls, body)
+      ...findEmbeddedMembers(cls),
+      ...findProtoMembers(cls, body)
     ];
 
     cls.staticMembers = [
@@ -189,7 +203,7 @@ export default function transform(src) {
     cls.node.get('comments').replace(additionalComments);
 
     members.forEach(m => {
-      if (m.member.type === 'FunctionExpression') {
+      if (m.source === 'prototype') {
         m.node.replace();
       }
     });
@@ -321,7 +335,7 @@ function findStaticMembers(cls, nodes) {
   });
 }
 
-function findProtoMethods(cls, nodes) {
+function findProtoMembers(cls, nodes) {
 
   const names = matcher`
     ${cls.name}.prototype.$1 = $2;
@@ -334,12 +348,13 @@ function findProtoMethods(cls, nodes) {
       name: identifier.value.name,
       member: member.value,
       comments: node.get('comments').value,
-      node
+      node,
+      source: 'prototype'
     };
   });
 }
 
-function findEmbeddedMethods(cls) {
+function findEmbeddedMembers(cls) {
 
   const memberDeclarations = matcher`
     this.$1 = $2;
@@ -352,7 +367,8 @@ function findEmbeddedMethods(cls) {
       name: identifier.value.name,
       member: member.value,
       comments: node.get('comments').value,
-      node
+      node,
+      source: 'constructor'
     };
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bio-dts",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Generate sane and clean types from JavaScript sources",
   "type": "module",
   "main": "index.js",