utilities for working with typescript's AST. 

utilities for working with typescript's AST

ajaff

tsutils

* `getSymbolOfClassLikeDeclaration` no longer crashes on anonymous mixin classes

* `getSymbolOfClassLikeDeclaration` to retrieve the symbol of class declarations and expressions regardless whether they have a name or not

* `getBaseOfClassLikeDeclaration` to conventiently get the expression after `extends`

* `getBaseClassMemberOfClassElement` to look up the declaration of a class member in the base class

* `getConstructorTypeOfClassLikeDeclaration` now really returns the constructor type (the static side of the class), previously it returned the instance type

* `hasExhaustiveCaseClauses` allows additional case clauses with `null`, `undefined` and `never`

* JSDoc is preserved in declaration files

* Comments are presered in transpiled code

* Everything you need to handle the control flow changes of TypeScript@3.7

  * `callExpressionAffectsControlFlow` to determine whether a CallExpression affects control flow by returning `never` or `asserts`

  * `hasExhaustiveCaseClauses` to determine whether a SwitchStatement's CaseClauses handle every possible value

  * `endsControlFlow` and `getControlFlowEnd` take an optional `checker` parameter to recognize exhaustive SwitchStatements and control flow effects of CallExpressions

* `formatPseudoBigInt` converts TypeScript's representation of a BigInt to its literal representation as you would write it in your source code

* `getAstNodeAtPosition` similar to `getTokenAtPosition`, but only operates on AST Nodes

* `removeOptionalChainingUndefinedMarkerType` and `isOptionalChainingUndefinedMarkerType` to handle types originating in an optional chain

* `findImports` and `findImportLikeNodes`: prepare for import assertions

* `getTsCheckDirective` as new name for `getCheckJsDirective`

* `getCheckJsDirective` is now deprecated

* `getUsageDomain`: handles NamespaceExport and NamedTupleMember

* `getPropertyName`: handles parentheses and negative numeric literals, excludes RegExp literals and private identifiers

* `getSingleLateBoundPropertyNameOfPropertyName` and `getLateBoundPropertyNamesOfPropertyName`: handles private identifiers

* `hasAccessModifier`: handles JSDoc access modifier

* `hasSideEffects`: correctly determines side effects of (static) property initializers

* `isExpressionValueUsed`: handle nullish coalescing and conditional assignment operators

* `canHaveJsDoc`: aligned with upstream changes in TypeScript

  * `noUncheckedIndexedAccess` requires `strictNullChecks`

  * `emitDeclarationOnly` requires `declaration`

* `isInConstContext`: handle template string interpolations

* excluded unnecessary files from npm package

* `isValidJsxIdentifier`, `isValidPropertyAccess`, `isValidPropertyName`: fix unicode character width handling

* `isValidJsxIdentifier` added an optional parameter to specify the target ECMAScript version

* `isValidJsxIdentifier` now handles astral plane characters

* added `getIteratorYieldResultFromIteratorResult` to extract the `yield`ed type from `IteratorResult<TYield, TReturn, TNext>`

* `isValidIdentifier`, `isValidPropertyName`, `isValidPropertyAccess`, `isValidNumericLiteral` added an optional parameter to specify the target ECMAScript version

* `isValidPropertyName`, `isValidPropertyAccess` now handle astral plane characters

* `findImports`: fixed crash on nested namespaces

* added `getInstanceTypeOfClassLikeDeclaration` and `getConstructorTypeOfClassLikeDeclaration`

* added `AccessKind.Delete` to `getAccessKind`: `getAccessKind(node) & AccessKind.Modification` can now be used to restore the old behavior of `isReassignmentTarget(node)`

* `getAccessKind` determines whether an expression is read from, written to or both

* optimized `getPropertyOfType` for unambiguous property names to partially work around https://github.com/microsoft/TypeScript/issues/31565

  "description": "utilities for working with typescript's AST",

    "precompile": "rimraf \"{,util,typeguard,test{,/rules}/*.{js,d.ts,js.map}\"",

    "lint:tslint": "wotan -m @fimbul/valtyr",

    "test": "mocha test/*Tests.js && tslint --test 'test/rules/**/tslint.json'",

    "verify": "run-s compile lint coverage",

    "report-coverage": "cat ./coverage/lcov.info | coveralls",

    "github-release": "node ./scripts/github-release.js",

    "postpublish": "git push origin master --tags && run-s github-release"

    "url": "https://github.com/ajafff/tsutils"

    "github-release-from-changelog": "^1.3.0",

    "tslint-consistent-codestyle": "^1.11.0",

    "typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta"

Object.defineProperty(exports, "__esModule", { value: true });

exports.getBaseClassMemberOfClassElement = exports.getIteratorYieldResultFromIteratorResult = exports.getInstanceTypeOfClassLikeDeclaration = exports.getConstructorTypeOfClassLikeDeclaration = exports.getSymbolOfClassLikeDeclaration = exports.getPropertyNameFromType = exports.symbolHasReadonlyDeclaration = exports.isPropertyReadonlyInType = exports.getPropertyOfType = exports.isBooleanLiteralType = exports.isFalsyType = exports.isThenableType = exports.someTypePart = exports.intersectionTypeParts = exports.unionTypeParts = exports.getCallSignaturesOfType = exports.isTypeAssignableToString = exports.isTypeAssignableToNumber = exports.isOptionalChainingUndefinedMarkerType = exports.removeOptionalChainingUndefinedMarkerType = exports.removeOptionalityFromType = exports.isEmptyObjectType = void 0;

const type_1 = require("../typeguard/type");

const node_1 = require("../typeguard/node");

        type.objectFlags & ts.ObjectFlags.Anonymous &&

        type.getProperties().length === 0 &&

        type.getCallSignatures().length === 0 &&

        type.getConstructSignatures().length === 0 &&

        type.getStringIndexType() === undefined &&

        type.getNumberIndexType() === undefined) {

        const baseTypes = type.getBaseTypes();

        return baseTypes === undefined || baseTypes.every(isEmptyObjectType);

exports.isEmptyObjectType = isEmptyObjectType;

function removeOptionalityFromType(checker, type) {

    if (!containsTypeWithFlag(type, ts.TypeFlags.Undefined))

    const allowsNull = containsTypeWithFlag(type, ts.TypeFlags.Null);

    type = checker.getNonNullableType(type);

    return allowsNull ? checker.getNullableType(type, ts.TypeFlags.Null) : type;

exports.removeOptionalityFromType = removeOptionalityFromType;

function containsTypeWithFlag(type, flag) {

    for (const t of unionTypeParts(type))

        if (util_1.isTypeFlagSet(t, flag))

function removeOptionalChainingUndefinedMarkerType(checker, type) {

        return isOptionalChainingUndefinedMarkerType(checker, type) ? type.getNonNullableType() : type;

        if (isOptionalChainingUndefinedMarkerType(checker, t)) {

            containsUndefinedMarker = true;

        ? checker.getNullableType(type.getNonNullableType(), flags)

exports.removeOptionalChainingUndefinedMarkerType = removeOptionalChainingUndefinedMarkerType;

function isOptionalChainingUndefinedMarkerType(checker, t) {

    return util_1.isTypeFlagSet(t, ts.TypeFlags.Undefined) && checker.getNullableType(t.getNonNullableType(), ts.TypeFlags.Undefined) !== t;

exports.isOptionalChainingUndefinedMarkerType = isOptionalChainingUndefinedMarkerType;

function isTypeAssignableToNumber(checker, type) {

    return isTypeAssignableTo(checker, type, ts.TypeFlags.NumberLike);

exports.isTypeAssignableToNumber = isTypeAssignableToNumber;

function isTypeAssignableToString(checker, type) {

    return isTypeAssignableTo(checker, type, ts.TypeFlags.StringLike);

exports.isTypeAssignableToString = isTypeAssignableToString;

function isTypeAssignableTo(checker, type, flags) {

        if (type_1.isTypeParameter(t) && t.symbol !== undefined && t.symbol.declarations !== undefined) {

            if (typeParametersSeen === undefined) {

                typeParametersSeen = new Set([t]);

            else if (!typeParametersSeen.has(t)) {

                typeParametersSeen.add(t);

            const declaration = t.symbol.declarations[0];

            if (declaration.constraint === undefined)

            return check(checker.getTypeFromTypeNode(declaration.constraint));

        if (type_1.isIntersectionType(t))

        return util_1.isTypeFlagSet(t, flags);

            signatures.push(...getCallSignaturesOfType(t));

    if (type_1.isIntersectionType(type)) {

function getSymbolOfClassLikeDeclaration(node, checker) {

    return node.name !== undefined ? checker.getSymbolAtLocation(node.name) : checker.getTypeAtLocation(node).symbol;

    return checker.getSymbolAtLocation((_a = node.name) !== null && _a !== void 0 ? _a : util_1.getChildOfKind(node, ts.SyntaxKind.ClassKeyword));

exports.getSymbolOfClassLikeDeclaration = getSymbolOfClassLikeDeclaration;

function getConstructorTypeOfClassLikeDeclaration(node, checker) {

    return node.kind === ts.SyntaxKind.ClassExpression

        ? checker.getTypeAtLocation(node)

        : checker.getTypeOfSymbolAtLocation(getSymbolOfClassLikeDeclaration(node, checker), node);

exports.getConstructorTypeOfClassLikeDeclaration = getConstructorTypeOfClassLikeDeclaration;

function getInstanceTypeOfClassLikeDeclaration(node, checker) {

    return node.kind === ts.SyntaxKind.ClassDeclaration

        : checker.getDeclaredTypeOfSymbol(getSymbolOfClassLikeDeclaration(node, checker));

exports.getInstanceTypeOfClassLikeDeclaration = getInstanceTypeOfClassLikeDeclaration;

function getIteratorYieldResultFromIteratorResult(type, node, checker) {

    return type_1.isUnionType(type) && type.types.find((t) => {

        const done = t.getProperty('done');

            isBooleanLiteralType(removeOptionalityFromType(checker, checker.getTypeOfSymbolAtLocation(done, node)), false);

exports.getIteratorYieldResultFromIteratorResult = getIteratorYieldResultFromIteratorResult;

/** Lookup the declaration of a class member in the super class. */

function getBaseClassMemberOfClassElement(node, checker) {

    if (!node_1.isClassLikeDeclaration(node.parent))

    const base = util_1.getBaseOfClassLikeExpression(node.parent);

    const name = util_1.getSingleLateBoundPropertyNameOfPropertyName(node.name, checker);

    const baseType = checker.getTypeAtLocation(util_1.hasModifier(node.modifiers, ts.SyntaxKind.StaticKeyword)

    return getPropertyOfType(baseType, name.symbolName);

exports.getBaseClassMemberOfClassElement = getBaseClassMemberOfClassElement;

		@@ -0,1 +1,7 @@
		# 3.19.1

		Bugfixes:

		* `getSymbolOfClassLikeDeclaration` no longer crashes on anonymous mixin classes

		# 3.19.0
		@@ -2,0 +8,0 @@

		{
		"name": "tsutils",
		"version": "3.19.0",
		"version": "3.19.1",
		"description": "utilities for working with typescript's AST",
		@@ -5,0 +5,0 @@ "scripts": {

		@@ -259,3 +259,4 @@ "use strict";
		function getSymbolOfClassLikeDeclaration(node, checker) {
		return node.name !== undefined ? checker.getSymbolAtLocation(node.name) : checker.getTypeAtLocation(node).symbol;
		var _a;
		return checker.getSymbolAtLocation((_a = node.name) !== null && _a !== void 0 ? _a : util_1.getChildOfKind(node, ts.SyntaxKind.ClassKeyword));
		}
		@@ -262,0 +263,0 @@ exports.getSymbolOfClassLikeDeclaration = getSymbolOfClassLikeDeclaration;

Improved metrics