bio-dts 0.2.0 → 0.2.1

package/lib/post-transform.js

@@ -36,6 +36,12 @@ export default function transform(src) {
     }
 
     // TODO(nikku): transform illegal typescript methods into override calls
+
+    // TODO(nikku): remove annotations
+    //
+    // * @typedef
+    // * @class
+    // * @constructor
   });
 
   return print(ast).code;

package/lib/pre-transform.js

@@ -146,19 +146,31 @@ export default function transform(src) {
   const ast = parse(src);
   const body = path(ast).get('program', 'body');
 
+  const inheritsImports = findInheritsImports(body);
+
   const classes = findConstructors(body);
 
+  // query
   for (const cls of classes) {
-    const members = cls.members = [
+    cls.members = [
       ...findEmbeddedMethods(cls),
       ...findProtoMethods(cls, body)
     ];
 
-    const staticMembers = cls.staticMembers = [
+    cls.staticMembers = [
       ...findStaticMembers(cls, body)
     ];
 
-    const superDeclaration = cls.superDeclaration = findSuperDeclarations(cls, body);
+    cls.superDeclaration = findSuperDeclarations(cls, body, inheritsImports);
+  }
+
+  // transform
+  for (const cls of classes) {
+    const {
+      members,
+      staticMembers,
+      superDeclaration
+    } = cls;
 
     if (superDeclaration) {
       cls.ctor.get('body', 'body').unshift(superCall());
@@ -187,26 +199,34 @@ export default function transform(src) {
     });
 
     if (superDeclaration) {
-      superDeclaration.importDeclarations.forEach(m => m.node.replace());
       superDeclaration.inheritsExpression.node.replace();
     }
   }
 
+  inheritsImports.forEach(m => m.node.replace());
+
   return print(ast).code;
 }
 
-function findSuperDeclarations(cls, nodes) {
-
+function findInheritsImports(nodes) {
   const importsMatches = matcher`
     import $1 from 'inherits-browser';
   `;
 
-  const importDeclarations = importsMatches(nodes);
+  return importsMatches(nodes).map(m => {
+    return {
+      node: m[0],
+      name: m[1].value.name
+    };
+  });
+}
+
+function findSuperDeclarations(cls, nodes, importDeclarations) {
 
-  for (const [ _, identifier ] of importDeclarations) {
+  for (const { name: inheritsName } of importDeclarations) {
 
     const inheritsMatches = matcher`
-      ${identifier.value.name}(${cls.name}, $1);
+      ${inheritsName}(${cls.name}, $1);
     `;
 
     const inheritsExpressions = inheritsMatches(nodes);
@@ -230,7 +250,6 @@ function findSuperDeclarations(cls, nodes) {
       const superCalls = superCallMatches(cls.ctor.get('body', 'body'));
 
       return {
-        importDeclarations: importDeclarations.map(m => ({ node: m[0] })),
         superCalls: superCalls.map(m => ({ node: m[0] })),
         clazz,
         inheritsExpression

package/package.json

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