bio-dts 0.2.0 → 0.3.0

package/lib/parsers/jsdoc.js

@@ -0,0 +1,159 @@
+function skipWhitespace(str, pos) {
+  let i = pos;
+
+  let char;
+  for (; (char = str.charAt(i)) && char !== '\n' && /\s/.test(char); i++) {
+
+    // ignore
+  }
+
+  return i;
+}
+
+function skipText(str, pos) {
+  let i = pos;
+  let char;
+
+  for (; (char = str.charAt(i)) && /\S/.test(char); i++) {
+
+    // ignore
+  }
+
+  return i;
+}
+
+function findClose(str, pos, openChar, closeChar) {
+
+  if (str.charAt(pos) !== openChar) {
+    return false;
+  }
+
+  let char;
+
+  let i = pos;
+
+  let open = 0;
+
+  while ((char = str.charAt(i++))) {
+    switch (char) {
+    case openChar:
+      open++;
+      break;
+    case closeChar:
+      if (--open === 0) {
+        return {
+          start: pos,
+          end: i,
+          value: str.substring(pos, i)
+        };
+      }
+      break;
+    }
+  }
+}
+
+function findNewline(str, pos) {
+
+  let i = pos;
+  let char;
+
+  for (; (char = str.charAt(i)) && /[^\n]/.test(char); i++) {
+
+    // ignore
+  }
+
+  return i;
+}
+
+export function parse(str) {
+
+  var i = 0, j;
+
+  var tags = [];
+  var tag;
+
+  while ((i = str.indexOf('@', i)) && i !== -1) {
+    j = i + 1;
+    tag = {
+      start: i
+    };
+
+    // parse tag name
+    j = skipText(str, i);
+
+    tag.name = str.substring(i + 1, j);
+
+    i = skipWhitespace(str, j);
+
+    // parse type
+    if ([ 'param', 'return', 'returns', 'typedef' ].includes(tag.name)) {
+
+      let match = findClose(str, i, '{', '}');
+
+      if (match) {
+        tag.type = match;
+
+        i = skipWhitespace(str, match.end);
+      }
+    }
+
+    // parse param
+    if ([ 'param', 'typedef' ].includes(tag.name)) {
+
+      let match = tag.name === 'param' && findClose(str, i, '[', ']');
+
+      if (match) {
+        tag.param = match;
+
+        const contents = tag.param.contents = str.substring(match.start + 1, match.end - 1);
+        const idxEq = contents.indexOf('=');
+
+        tag.param.name = idxEq !== -1 ? contents.substring(0, idxEq) : contents;
+      } else {
+        j = skipText(str, i);
+
+        tag.param = {
+          start: i,
+          end: j,
+          name: str.substring(i, j),
+          value: str.substring(i, j)
+        };
+      }
+
+      i = skipWhitespace(str, tag.param.end);
+    }
+
+    j = findNewline(str, i);
+
+    tag.description = i !== j ? {
+      start: i,
+      end: j,
+      value: str.substring(i, j)
+    } : null;
+
+    tag.end = j;
+
+    tags.push(tag);
+
+    i = j + 1;
+  }
+
+  return tags;
+}
+
+export function dbg(str, pos) {
+
+  const arr = Array.from(str);
+
+  arr.splice(pos, 0, '|');
+
+  return arr.join('');
+}
+
+export function replace(str, range, contents) {
+  const arr = Array.from(str);
+
+  arr.splice(range.start, range.end - range.start, contents);
+
+  return arr.join('');
+}

package/lib/post-transform.js

@@ -1,5 +1,14 @@
 import { isArray, isNode, keys, parseDts, path, print } from './util.js';
 
+import {
+  builders as b
+} from 'ast-types';
+
+import {
+  parse as parseJSDoc,
+  replace as replaceJSDoc
+} from './parsers/jsdoc.js';
+
 
 /**
  * @param { { name: string, comments?: any[] } }
@@ -28,35 +37,106 @@ export default function transform(src) {
   const ast = parseDts(src);
   const body = path(ast).get('program', 'body');
 
+  const replacements = [];
+
+  function replace(path, ...args) {
+    replacements.push([ path, args ]);
+
+    return false;
+  }
+
   traverse(body, function(path) {
 
+    const {
+      value
+    } = path;
+
     // filter private members
-    if (!isPublic(path.value)) {
-      path.replace();
+    if (!isPublic(value)) {
+      return replace(path);
     }
 
     // TODO(nikku): transform illegal typescript methods into override calls
+
+    // TODO(nikku): remove annotations
+    //
+    // * @typedef
+    // * @class
+    // * @constructor
+    // * @template
+    // * @method
+
+    const comments = path.get('comments') || { value: [] };
+
+    for (const key of keys(comments.value || []).reverse()) {
+
+      const comment = comments.get(key);
+
+      const replacements = [];
+
+      const doc = comment.value.value.replace(/\n\s+/g, '\n ');
+      const tags = parseJSDoc(doc);
+
+      for (const tag of tags) {
+        if (/class|constructor|template|method|typedef/.test(tag.name)) {
+          replacements.push([ { start: tag.start - 4, end: tag.end } ]);
+
+          continue;
+        }
+
+        if (tag.type) {
+          replacements.push([ { start: tag.type.start - 1, end: tag.type.end }, '' ]);
+        }
+
+        if (tag.param) {
+          replacements.push([ tag.param, tag.param.name ]);
+        }
+      }
+
+      const newDoc = replacements.slice().reverse().reduce((newDoc, r) => {
+
+        const [ { start, end }, replacement = '' ] = r;
+
+        return replaceJSDoc(newDoc, { start, end }, replacement);
+      }, doc);
+
+      // remove entirely, if empty
+      if (!newDoc.replace(/[/*\s]/g, '')) {
+        replace(comment);
+      } else {
+        replace(comment, b.commentBlock.from({
+          type: 'CommentBlock',
+          leading: true,
+          value: newDoc
+        }));
+      }
+    }
+
   });
 
+  for (const [ path, args ] of replacements) {
+    path.replace(...args);
+  }
+
   return print(ast).code;
 }
 
 function traverse(path, cb) {
-  cb(path);
+  const val = path.value;
 
-  if (path.parentPath) {
-    const val = path.value;
-
-    if (!isNode(val) && !isArray(val)) {
-      return;
-    }
+  if (!isNode(val) && !isArray(val)) {
+    return;
+  }
 
-    for (const key of keys(val).reverse()) {
-      if ([ 'loc', 'start', 'end' ].includes(key)) {
-        continue;
-      }
+  if (cb(path) === false) {
+    return;
+  }
 
-      traverse(path.get(key), cb);
+  for (const key of keys(val).reverse()) {
+    if ([ 'loc', 'start', 'end' ].includes(key)) {
+      continue;
     }
+
+    traverse(path.get(key), cb);
   }
 }

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.3.0",
   "description": "Generate sane and clean types from JavaScript sources",
   "type": "module",
   "main": "index.js",