tsd-jsdoc - npm Package Compare versions

Comparing version 2.1.3 to 2.2.0

dist/create_helpers.js

@@ -9,24 +9,2 @@ "use strict";
 const readonlyModifier = ts.createModifier(ts.SyntaxKind.ReadonlyKeyword);
-const rgxIdentifier = /^[a-zA-Z\$_][a-zA-Z0-9\$_]+$/;
-const reservedWords = [
-    'break', 'do', 'instanceof', 'typeof',
-    'case', 'else', 'new', 'var',
-    'catch', 'finally', 'return', 'void',
-    'continue', 'for', 'switch', 'while',
-    'debugger', 'function', 'this', 'with',
-    'default', 'if', 'throw',
-    'delete', 'in', 'try',
-    'class', 'enum', 'extends', 'super',
-    'const', 'export', 'import',
-    'implements', 'let', 'private', 'public', 'yield',
-    'interface', 'package', 'protected', 'static',
-    'null', 'true', 'false',
-];
-function isValidIdentifier(name) {
-    if (!name || !rgxIdentifier.test(name))
-        return false;
-    if (reservedWords.indexOf(name) !== -1)
-        return false;
-    return true;
-}
 function validateClassLikeChildren(children, validate, msg) {
@@ -206,10 +184,5 @@ if (children) {
         flags |= ts.NodeFlags.NestedNamespace;
-    if (children) {
+    if (children)
         body = ts.createModuleBlock(children);
-    }
-    let name;
-    if (isValidIdentifier(doclet.name))
-        name = ts.createIdentifier(doclet.name);
-    else
-        name = ts.createStringLiteral(doclet.name);
+    const name = ts.createStringLiteral(doclet.name);
     return handleComment(doclet, ts.createModuleDeclaration(undefined, mods, name, body, flags));
@@ -216,0 +189,0 @@ }

dist/Emitter.js

@@ -23,4 +23,4 @@ "use strict";
 class Emitter {
-    constructor(allowPrivate) {
-        this.allowPrivate = allowPrivate;
+    constructor(options) {
+        this.options = options;
         this.results = [];
@@ -101,3 +101,3 @@ this._treeRoots = [];
                 if (isParentClassLike && shouldMoveOutOfClass(doclet)) {
-                    const mod = this._getOrCreateClassModule(parent);
+                    const mod = this._getOrCreateClassNamespace(parent);
                     if (interfaceMerge)
@@ -156,2 +156,3 @@ mod.children.push(interfaceMerge);
                     return create_helpers_1.createNamespaceMember(node.doclet);
+            case 'callback':
             case 'function':
@@ -176,2 +177,4 @@ if (node.doclet.memberof) {
                 return create_helpers_1.createTypedef(node.doclet, children);
+            case 'file':
+                return null;
             case 'event':
@@ -184,5 +187,12 @@ return null;
     _ignoreDoclet(doclet) {
-        return doclet.kind === 'package'
+        if (doclet.kind === 'package'
             || doclet.ignore
-            || (!this.allowPrivate && doclet.access === 'private');
+            || (!this.options.private && doclet.access === 'private')) {
+            return true;
+        }
+        if (doclet.access === undefined) {
+            return false;
+        }
+        const accessLevels = ["private", "package", "protected", "public"];
+        return accessLevels.indexOf(doclet.access.toString()) < accessLevels.indexOf(this.options.access || "package");
     }
@@ -192,18 +202,18 @@ _getInterfaceKey(longname) {
     }
-    _getModuleKey(longname) {
-        return longname ? longname + '$$module$helper' : '';
+    _getNamespaceKey(longname) {
+        return longname ? longname + '$$namespace$helper' : '';
     }
-    _getOrCreateClassModule(obj) {
+    _getOrCreateClassNamespace(obj) {
         if (obj.doclet.kind === 'namespace')
             return obj;
-        const moduleKey = this._getModuleKey(obj.doclet.longname);
-        let mod = this._treeNodes[moduleKey];
+        const namespaceKey = this._getNamespaceKey(obj.doclet.longname);
+        let mod = this._treeNodes[namespaceKey];
         if (mod)
             return mod;
-        mod = this._treeNodes[moduleKey] = {
+        mod = this._treeNodes[namespaceKey] = {
             doclet: {
-                kind: 'module',
+                kind: 'namespace',
                 name: obj.doclet.name,
                 scope: 'static',
-                longname: moduleKey,
+                longname: namespaceKey,
             },
@@ -218,3 +228,3 @@ children: [],
             }
-            let parentMod = this._getOrCreateClassModule(parent);
+            let parentMod = this._getOrCreateClassNamespace(parent);
             mod.doclet.memberof = parentMod.doclet.longname;
@@ -221,0 +231,0 @@ parentMod.children.push(mod);

dist/publish.js

@@ -12,3 +12,3 @@ "use strict";
     logger_1.setVerbose(!!opts.verbose);
-    const emitter = new Emitter_1.Emitter(!!opts.private);
+    const emitter = new Emitter_1.Emitter(opts);
     emitter.parse(docs);
@@ -29,3 +29,7 @@ if (opts.destination === 'console') {
         const pkg = pkgArray[0];
-        const out = path.join(opts.destination, opts.outFile || (pkg && pkg.name ? `${pkg.name}.d.ts` : 'types.d.ts'));
+        let definitionName = 'types';
+        if (pkg && pkg.name) {
+            definitionName = pkg.name.split('/').pop() || definitionName;
+        }
+        const out = path.join(opts.destination, opts.outFile || `${definitionName}.d.ts`);
         fs.writeFileSync(out, emitter.emit());
@@ -32,0 +36,0 @@ }

dist/type_resolve_helpers.js

@@ -6,9 +6,270 @@ "use strict";
 const PropTree_1 = require("./PropTree");
-const rgxObjectTokenize = /(<|>|,)/;
+const rgxObjectTokenize = /(<|>|,|\(|\)|\||\{|\}|:)/;
 const rgxCommaAll = /,/g;
 const rgxParensAll = /\(|\)/g;
 const anyTypeNode = ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword);
+const voidTypeNode = ts.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
 const strTypeNode = ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
-const anyGeneric = { kind: 'type', name: 'any', resolved: anyTypeNode };
-const strGeneric = { kind: 'type', name: 'string', resolved: strTypeNode };
+var ENodeType;
+(function (ENodeType) {
+    ENodeType[ENodeType["GENERIC"] = 0] = "GENERIC";
+    ENodeType[ENodeType["UNION"] = 1] = "UNION";
+    ENodeType[ENodeType["FUNCTION"] = 2] = "FUNCTION";
+    ENodeType[ENodeType["TUPLE"] = 3] = "TUPLE";
+    ENodeType[ENodeType["TYPE"] = 4] = "TYPE";
+    ENodeType[ENodeType["OBJECT"] = 5] = "OBJECT";
+})(ENodeType || (ENodeType = {}));
+class StringTreeNode {
+    constructor(name, type, parent) {
+        this.name = name;
+        this.type = type;
+        this.parent = parent;
+        this.children = [];
+    }
+    dump(indent = 0) {
+        console.log(`${'  '.repeat(indent)}name: ${this.name}, type:${this.typeToString()}`);
+        this.children.forEach((child) => {
+            child.dump(indent + 1);
+        });
+    }
+    typeToString() {
+        switch (this.type) {
+            case ENodeType.GENERIC:
+                return 'GENERIC';
+            case ENodeType.UNION:
+                return 'UNION';
+            case ENodeType.FUNCTION:
+                return 'FUNCTION';
+            case ENodeType.TUPLE:
+                return 'TUPLE';
+            case ENodeType.TYPE:
+                return 'TYPE';
+            case ENodeType.OBJECT:
+                return 'OBJECT';
+            default:
+                return 'UNKNOWN';
+        }
+    }
+}
+function resolveComplexTypeName(name, doclet) {
+    const root = generateTree(name);
+    if (!root) {
+        logger_1.warn(`failed to generate tree for ${name}, defaulting to any`);
+        return anyTypeNode;
+    }
+    return resolveTree(root);
+}
+exports.resolveComplexTypeName = resolveComplexTypeName;
+function generateTree(name, parent = null) {
+    const anyNode = new StringTreeNode('any', ENodeType.TYPE, parent);
+    const parts = name.split(rgxObjectTokenize).filter(function (e) {
+        return e.trim() !== '';
+    });
+    for (let i = 0; i < parts.length; ++i) {
+        const part = parts[i].trim();
+        const partUpper = part.toUpperCase();
+        if (part.endsWith('.')) {
+            const matchingIndex = findMatchingBracket(parts, i + 1, '<', '>');
+            if (matchingIndex === -1) {
+                logger_1.warn(`Unable to find matching '<', '>' brackets in '${part}', defaulting to \`any\``, name);
+                return anyNode;
+            }
+            const node = new StringTreeNode(part.substring(0, part.length - 1), ENodeType.GENERIC, parent);
+            generateTree(parts.slice(i + 2, matchingIndex).join(''), node);
+            if (!parent)
+                return node;
+            parent.children.push(node);
+            i = matchingIndex + 1;
+            continue;
+        }
+        if (part === '(') {
+            const matchingIndex = findMatchingBracket(parts, i, '(', ')');
+            if (matchingIndex === -1) {
+                logger_1.warn(`Unable to find matching '(', ')' brackets in '${part}', defaulting to \`any\``, name);
+                return anyNode;
+            }
+            const node = new StringTreeNode('Union', ENodeType.UNION, parent);
+            generateTree(parts.slice(i + 1, matchingIndex).join(''), node);
+            if (!parent)
+                return node;
+            parent.children.push(node);
+            i = matchingIndex + 1;
+            continue;
+        }
+        if (part === '{') {
+            const matchingIndex = findMatchingBracket(parts, i, '{', '}');
+            if (matchingIndex === -1) {
+                logger_1.warn(`Unable to find matching '{', '}' brackets in '${part}', defaulting to \`any\``, name);
+                return anyNode;
+            }
+            const node = new StringTreeNode('Object', ENodeType.OBJECT, parent);
+            generateTree(parts.slice(i + 1, matchingIndex).join(''), node);
+            if (!parent)
+                return node;
+            parent.children.push(node);
+            i = matchingIndex + 1;
+            continue;
+        }
+        if (partUpper === 'FUNCTION') {
+            const node = new StringTreeNode(part, ENodeType.FUNCTION, parent);
+            let matchingIndex = findMatchingBracket(parts, i + 1, '(', ')');
+            if (matchingIndex === -1) {
+                logger_1.warn(`Unable to find matching '(', ')' brackets in '${part}', defaulting to \`any\``, name);
+                return anyNode;
+            }
+            if (matchingIndex > i + 2)
+                generateTree(parts.slice(i + 2, matchingIndex).join(''), node);
+            if (parts.length > matchingIndex + 2 && parts[matchingIndex + 1] === ':') {
+                generateTree(parts[matchingIndex + 2], node);
+                matchingIndex += 2;
+            }
+            else {
+                node.children.push(new StringTreeNode('void', ENodeType.TYPE, node));
+            }
+            if (!parent)
+                return node;
+            parent.children.push(node);
+            i = matchingIndex + 1;
+            continue;
+        }
+        if (part === '|' || part === ',' || part === ':') {
+            continue;
+        }
+        const node = new StringTreeNode(part, ENodeType.TYPE, parent);
+        if (part === '*')
+            node.name = 'any';
+        else if (partUpper === 'OBJECT')
+            node.name = 'object';
+        if (!parent)
+            return node;
+        parent.children.push(node);
+    }
+    return anyNode;
+}
+function findMatchingBracket(parts, startIndex, openBracket, closeBracket) {
+    let count = 0;
+    for (let i = startIndex; i < parts.length; ++i) {
+        if (parts[i] === openBracket) {
+            ++count;
+        }
+        else if (parts[i] === closeBracket) {
+            if (--count === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function resolveTree(node, parentTypes = null) {
+    const childTypes = [];
+    node.children.forEach((child) => resolveTree(child, childTypes));
+    const upperName = node.name.toUpperCase();
+    switch (node.type) {
+        case ENodeType.OBJECT:
+            const objectProperties = [];
+            for (var i = 0; i < node.children.length; i = i + 2) {
+                let valType = childTypes[i + 1];
+                if (!valType) {
+                    logger_1.warn('Unable to resolve object value type, this is likely due to invalid JSDoc. Defaulting to \`any\`.', node);
+                    valType = anyTypeNode;
+                }
+                const property = ts.createPropertySignature(undefined, ts.createIdentifier(node.children[i].name), undefined, valType, undefined);
+                objectProperties.push(property);
+            }
+            const objectNode = ts.createTypeLiteralNode(objectProperties);
+            ts.setEmitFlags(objectNode, ts.EmitFlags.SingleLine);
+            if (!parentTypes)
+                return objectNode;
+            parentTypes.push(objectNode);
+            break;
+        case ENodeType.GENERIC:
+            let genericNode;
+            if (upperName === 'OBJECT') {
+                let keyType = childTypes[0];
+                if (!keyType) {
+                    logger_1.warn(`Unable to resolve object key type, this is likely due to invalid JSDoc. Defaulting to \`string\`.`);
+                    keyType = strTypeNode;
+                }
+                else if (node.children[0].type !== ENodeType.TYPE || (node.children[0].name !== 'string' && node.children[0].name !== 'number')) {
+                    logger_1.warn(`Invalid object key type. It must be \`string\` or \`number\`, but got: ${node.children[0].name}. Defaulting to \`string\`.`);
+                    keyType = strTypeNode;
+                }
+                let valType = childTypes[1];
+                if (!valType) {
+                    logger_1.warn('Unable to resolve object value type, this is likely due to invalid JSDoc. Defaulting to \`any\`.', parent);
+                    valType = anyTypeNode;
+                }
+                const indexParam = ts.createParameter(undefined, undefined, undefined, 'key', undefined, keyType, undefined);
+                const indexSignature = ts.createIndexSignature(undefined, undefined, [indexParam], valType);
+                genericNode = ts.createTypeLiteralNode([indexSignature]);
+            }
+            else if (upperName === 'ARRAY') {
+                let valType = childTypes[0];
+                if (!valType) {
+                    logger_1.warn('Unable to resolve array value type, defaulting to \`any\`.', node);
+                    valType = anyTypeNode;
+                }
+                genericNode = ts.createArrayTypeNode(valType);
+            }
+            else if (upperName === 'CLASS') {
+                let valType = childTypes[0];
+                if (!valType) {
+                    logger_1.warn('Unable to resolve class value type, defaulting to \`any\`.', node);
+                    valType = anyTypeNode;
+                }
+                genericNode = ts.createTypeQueryNode(ts.createIdentifier(node.children[0].name));
+            }
+            else {
+                if (childTypes.length === 0) {
+                    logger_1.warn('Unable to resolve generic type, defaulting to \`any\`.', node);
+                    childTypes.push(anyTypeNode);
+                }
+                if (upperName === 'PROMISE') {
+                    while (childTypes.length > 1)
+                        childTypes.pop();
+                }
+                genericNode = ts.createTypeReferenceNode(node.name, childTypes);
+            }
+            if (!parentTypes)
+                return genericNode;
+            parentTypes.push(genericNode);
+            break;
+        case ENodeType.UNION:
+            if (childTypes.length === 0) {
+                logger_1.warn('Unable to resolve any types for union, defaulting to \`any\`.', node);
+                childTypes.push(anyTypeNode);
+            }
+            const unionNode = ts.createUnionTypeNode(childTypes);
+            if (!parentTypes)
+                return unionNode;
+            parentTypes.push(unionNode);
+            break;
+        case ENodeType.FUNCTION:
+            const funcParameters = [];
+            if (childTypes.length === 0 || childTypes.length === 1) {
+                const anyArray = ts.createArrayTypeNode(anyTypeNode);
+                const dotDotDot = ts.createToken(ts.SyntaxKind.DotDotDotToken);
+                funcParameters.push(ts.createParameter(undefined, undefined, dotDotDot, 'params', undefined, anyArray, undefined));
+                if (childTypes.length === 0)
+                    childTypes.push(voidTypeNode);
+            }
+            console.log(`childTypes nodes: ${childTypes.length}`);
+            for (var i = 0; i < node.children.length - 1; ++i) {
+                const param = ts.createParameter(undefined, undefined, undefined, 'arg' + i, undefined, childTypes[i], undefined);
+                funcParameters.push(param);
+            }
+            const functionNode = ts.createFunctionTypeNode(undefined, funcParameters, childTypes[childTypes.length - 1]);
+            if (!parentTypes)
+                return functionNode;
+            parentTypes.push(functionNode);
+            break;
+        case ENodeType.TYPE:
+            const typeNode = ts.createTypeReferenceNode(node.name, undefined);
+            if (!parentTypes)
+                return typeNode;
+            parentTypes.push(typeNode);
+            break;
+    }
+    return anyTypeNode;
+}
 function toKeywordTypeKind(k) {
@@ -150,146 +411,5 @@ if (!k || k.length === 0)
     }
-    if (upperName.indexOf('.<') !== -1) {
-        return resolveGenericType(name);
-    }
-    if (name.indexOf('|') !== -1) {
-        const nameParts = name.split('|');
-        const types = [];
-        for (let i = 0; i < nameParts.length; ++i) {
-            const subName = nameParts[i].replace(rgxParensAll, '').trim();
-            types.push(resolveTypeName(subName, doclet));
-        }
-        return ts.createUnionTypeNode(types);
-    }
-    return ts.createTypeReferenceNode(name, undefined);
+    return resolveComplexTypeName(name);
 }
 exports.resolveTypeName = resolveTypeName;
-function resolveGenericType(name) {
-    const parts = name.split(rgxObjectTokenize);
-    if (parts.length <= 1) {
-        logger_1.warn('Invalid object type encountered, this is likely due to invalid JSDoc. Defaulting to \`any\`.', name);
-        return anyTypeNode;
-    }
-    let lastObj = null;
-    let parentStack = [];
-    for (let i = 0; i < parts.length; ++i) {
-        const partName = parts[i].trim();
-        if (!partName || partName === ',')
-            continue;
-        if (partName.endsWith('.')) {
-            const parent = parentStack[parentStack.length - 1];
-            lastObj = {
-                kind: 'generic',
-                name: partName.substr(0, partName.length - 1),
-                parent,
-                types: [],
-            };
-            if (parent)
-                parent.types.push(lastObj);
-        }
-        else if (partName === '<') {
-            if (lastObj && lastObj.kind === 'generic')
-                parentStack.push(lastObj);
-        }
-        else if (partName === '>') {
-            parentStack.pop();
-        }
-        else {
-            const parent = parentStack[parentStack.length - 1];
-            if (!parent) {
-                logger_1.warn(`Invalid generic format encountered when parsing type: ${name}`);
-                continue;
-            }
-            lastObj = {
-                kind: 'type',
-                name: partName,
-                parent,
-                resolved: resolveTypeName(partName),
-            };
-            parent.types.push(lastObj);
-        }
-    }
-    if (!lastObj || !lastObj.parent) {
-        logger_1.warn('Unable to resolve Object/Array complex type. Defaulting to \`any\`.', name);
-        return anyTypeNode;
-    }
-    return resolveGenericTypeTree(lastObj.parent);
-}
-exports.resolveGenericType = resolveGenericType;
-function resolveGenericTypeTree(bottom) {
-    let lastType = null;
-    let parent = bottom;
-    while (parent) {
-        if (parent.kind === 'generic') {
-            const upperName = parent.name.toUpperCase();
-            if (upperName === 'OBJECT') {
-                let keyType = parent.types[0];
-                if (!keyType) {
-                    logger_1.warn(`Unable to resolve object key type, this is likely due to invalid JSDoc. Defaulting to \`string\`.`);
-                    keyType = strGeneric;
-                }
-                else if (keyType.kind !== 'type'
-                    || (keyType.name !== 'string' && keyType.name !== 'number')) {
-                    logger_1.warn(`Invalid object key type. It must be \`string\` or \`number\`, but got: ${keyType.name}. Defaulting to \`string\`.`);
-                    keyType = strGeneric;
-                }
-                let valType = parent.types[1];
-                if (!valType) {
-                    logger_1.warn('Unable to resolve object value type, this is likely due to invalid JSDoc. Defaulting to \`any\`.', parent);
-                    valType = anyGeneric;
-                }
-                const indexParam = ts.createParameter(undefined, undefined, undefined, 'key', undefined, keyType.resolved, undefined);
-                if (!valType.resolved) {
-                    logger_1.warn('Unable to resolve object value type, this is likely a bug. Defaulting to \`any\`.', parent);
-                    valType.resolved = anyTypeNode;
-                }
-                const indexSignature = ts.createIndexSignature(undefined, undefined, [indexParam], valType.resolved);
-                lastType = parent.resolved = ts.createTypeLiteralNode([indexSignature]);
-            }
-            else if (upperName === 'ARRAY') {
-                let valType = parent.types[0];
-                if (!valType) {
-                    logger_1.warn('Unable to resolve array value type, defaulting to \`any\`.', parent);
-                    valType = anyGeneric;
-                }
-                if (!valType.resolved) {
-                    logger_1.warn('Unable to resolve array value type, defaulting to \`any\`.', parent);
-                    valType.resolved = anyTypeNode;
-                }
-                lastType = parent.resolved = ts.createArrayTypeNode(valType.resolved);
-            }
-            else if (upperName === 'CLASS') {
-                let valType = parent.types[0];
-                if (!valType) {
-                    logger_1.warn('Unable to resolve array value type, defaulting to \`any\`.', parent);
-                    valType = anyGeneric;
-                }
-                if (!valType.resolved) {
-                    logger_1.warn('Unable to resolve array value type, defaulting to \`any\`.', parent);
-                    valType.resolved = anyTypeNode;
-                }
-                lastType = parent.resolved = ts.createTypeQueryNode(ts.createIdentifier(valType.name));
-            }
-            else {
-                const typeNodes = [];
-                for (let i = 0; i < parent.types.length; ++i) {
-                    let valType = parent.types[i];
-                    if (!valType) {
-                        logger_1.warn('Unable to resolve generic type parameter, defaulting to \`any\`.', parent);
-                        valType = anyGeneric;
-                    }
-                    if (!valType.resolved) {
-                        logger_1.warn('Unable to resolve generic type parameter, defaulting to \`any\`.', parent);
-                        valType.resolved = anyTypeNode;
-                    }
-                    typeNodes.push(valType.resolved);
-                }
-                lastType = parent.resolved = ts.createTypeReferenceNode(parent.name, typeNodes);
-            }
-        }
-        parent = parent.parent;
-    }
-    if (lastType === null)
-        return anyTypeNode;
-    return lastType;
-}
 function resolveTypeLiteral(props) {
@@ -296,0 +416,0 @@ if (!props)

package.json

 {
   "name": "tsd-jsdoc",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "description": "Compiles JSDoc annotated javascript into a Typescript Declaration File (.d.ts).",
@@ -5,0 +5,0 @@ "main": "dist/publish.js",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

89585

increased by11.4%

Lines of code

1013

increased by11.81%

No dependency changes