--- /dev/null
+"use strict";
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var path = require("path");
+var tsutils_1 = require("tsutils");
+var ts = require("typescript");
+function getSourceFile(fileName, source) {
+ var normalizedName = path.normalize(fileName).replace(/\\/g, "/");
+ return ts.createSourceFile(normalizedName, source, ts.ScriptTarget.ES5,
+ /*setParentNodes*/ true);
+}
+exports.getSourceFile = getSourceFile;
+/** @deprecated See IDisabledInterval. */
+function doesIntersect(failure,
+// tslint:disable-next-line:deprecation
+disabledIntervals) {
+ return disabledIntervals.some(function (interval) {
+ var maxStart = Math.max(interval.startPosition, failure.getStartPosition().getPosition());
+ var minEnd = Math.min(interval.endPosition, failure.getEndPosition().getPosition());
+ return maxStart <= minEnd;
+ });
+}
+exports.doesIntersect = doesIntersect;
+/**
+ * @returns true if any modifier kinds passed along exist in the given modifiers array
+ *
+ * @deprecated use `hasModifier` from `tsutils`
+ */
+function hasModifier(modifiers) {
+ var modifierKinds = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ modifierKinds[_i - 1] = arguments[_i];
+ }
+ if (modifiers === undefined || modifierKinds.length === 0) {
+ return false;
+ }
+ return modifiers.some(function (m) { return modifierKinds.some(function (k) { return m.kind === k; }); });
+}
+exports.hasModifier = hasModifier;
+/**
+ * Determines if the appropriate bit in the parent (VariableDeclarationList) is set,
+ * which indicates this is a "let" or "const".
+ *
+ * @deprecated use `isBlockScopedVariableDeclarationList` from `tsutils`
+ */
+function isBlockScopedVariable(node) {
+ if (node.kind === ts.SyntaxKind.VariableDeclaration) {
+ var parent = node.parent;
+ return (parent.kind === ts.SyntaxKind.CatchClause ||
+ tsutils_1.isBlockScopedVariableDeclarationList(parent));
+ }
+ else {
+ return tsutils_1.isBlockScopedVariableDeclarationList(node.declarationList);
+ }
+}
+exports.isBlockScopedVariable = isBlockScopedVariable;
+/** @deprecated use `isBlockScopedVariableDeclarationList` and `getDeclarationOfBindingElement` from `tsutils` */
+function isBlockScopedBindingElement(node) {
+ var variableDeclaration = getBindingElementVariableDeclaration(node); // tslint:disable-line:deprecation
+ // if no variable declaration, it must be a function param, which is block scoped
+ return variableDeclaration === null || isBlockScopedVariable(variableDeclaration); // tslint:disable-line:deprecation
+}
+exports.isBlockScopedBindingElement = isBlockScopedBindingElement;
+/** @deprecated use `getDeclarationOfBindingElement` from `tsutils` */
+function getBindingElementVariableDeclaration(node) {
+ var currentParent = node.parent;
+ while (currentParent.kind !== ts.SyntaxKind.VariableDeclaration) {
+ if (currentParent.parent === undefined) {
+ return null; // function parameter, no variable declaration
+ }
+ else {
+ currentParent = currentParent.parent;
+ }
+ }
+ return currentParent;
+}
+exports.getBindingElementVariableDeclaration = getBindingElementVariableDeclaration;
+/**
+ * Finds a child of a given node with a given kind.
+ * Note: This uses `node.getChildren()`, which does extra parsing work to include tokens.
+ *
+ * @deprecated use `getChildOfKind` from `tsutils`
+ */
+function childOfKind(node, kind) {
+ return node.getChildren().find(function (child) { return child.kind === kind; });
+}
+exports.childOfKind = childOfKind;
+/**
+ * @returns true if some ancestor of `node` satisfies `predicate`, including `node` itself.
+ *
+ * @deprecated no longer used, use a `while` loop instead
+ */
+function someAncestor(node, predicate) {
+ return predicate(node) || (node.parent !== undefined && someAncestor(node.parent, predicate)); // tslint:disable-line:deprecation
+}
+exports.someAncestor = someAncestor;
+function ancestorWhere(node, predicate) {
+ var cur = node;
+ do {
+ if (predicate(cur)) {
+ return cur;
+ }
+ cur = cur.parent;
+ } while (cur !== undefined);
+ return undefined;
+}
+exports.ancestorWhere = ancestorWhere;
+/** @deprecated use `isBinaryExpression(node) && isAssignmentKind(node.operatorToken.kind)` with functions from `tsutils` */
+function isAssignment(node) {
+ if (node.kind === ts.SyntaxKind.BinaryExpression) {
+ var binaryExpression = node;
+ return (binaryExpression.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+ binaryExpression.operatorToken.kind <= ts.SyntaxKind.LastAssignment);
+ }
+ else {
+ return false;
+ }
+}
+exports.isAssignment = isAssignment;
+/**
+ * Bitwise check for node flags.
+ *
+ * @deprecated use `isNodeFlagSet` from `tsutils`
+ */
+function isNodeFlagSet(node, flagToCheck) {
+ // tslint:disable-next-line:no-bitwise
+ return (node.flags & flagToCheck) !== 0;
+}
+exports.isNodeFlagSet = isNodeFlagSet;
+/**
+ * Bitwise check for combined node flags.
+ *
+ * @deprecated no longer used
+ */
+function isCombinedNodeFlagSet(node, flagToCheck) {
+ // tslint:disable-next-line:no-bitwise
+ return (ts.getCombinedNodeFlags(node) & flagToCheck) !== 0;
+}
+exports.isCombinedNodeFlagSet = isCombinedNodeFlagSet;
+/**
+ * Bitwise check for combined modifier flags.
+ *
+ * @deprecated no longer used
+ */
+function isCombinedModifierFlagSet(node, flagToCheck) {
+ // tslint:disable-next-line:no-bitwise
+ return (ts.getCombinedModifierFlags(node) & flagToCheck) !== 0;
+}
+exports.isCombinedModifierFlagSet = isCombinedModifierFlagSet;
+/**
+ * Bitwise check for type flags.
+ *
+ * @deprecated use `isTypeFlagSet` from `tsutils`
+ */
+function isTypeFlagSet(type, flagToCheck) {
+ // tslint:disable-next-line:no-bitwise
+ return (type.flags & flagToCheck) !== 0;
+}
+exports.isTypeFlagSet = isTypeFlagSet;
+/**
+ * Bitwise check for symbol flags.
+ *
+ * @deprecated use `isSymbolFlagSet` from `tsutils`
+ */
+function isSymbolFlagSet(symbol, flagToCheck) {
+ // tslint:disable-next-line:no-bitwise
+ return (symbol.flags & flagToCheck) !== 0;
+}
+exports.isSymbolFlagSet = isSymbolFlagSet;
+/**
+ * Bitwise check for object flags.
+ * Does not work with TypeScript 2.0.x
+ *
+ * @deprecated use `isObjectFlagSet` from `tsutils`
+ */
+function isObjectFlagSet(objectType, flagToCheck) {
+ // tslint:disable-next-line:no-bitwise
+ return (objectType.objectFlags & flagToCheck) !== 0;
+}
+exports.isObjectFlagSet = isObjectFlagSet;
+/**
+ * @returns true if decl is a nested module declaration, i.e. represents a segment of a dotted module path.
+ *
+ * @deprecated use `decl.parent!.kind === ts.SyntaxKind.ModuleDeclaration`
+ */
+function isNestedModuleDeclaration(decl) {
+ // in a declaration expression like 'module a.b.c' - 'a' is the top level module declaration node and 'b' and 'c'
+ // are nested therefore we can depend that a node's position will only match with its name's position for nested
+ // nodes
+ return decl.name.pos === decl.pos;
+}
+exports.isNestedModuleDeclaration = isNestedModuleDeclaration;
+function unwrapParentheses(node) {
+ while (node.kind === ts.SyntaxKind.ParenthesizedExpression) {
+ node = node.expression;
+ }
+ return node;
+}
+exports.unwrapParentheses = unwrapParentheses;
+/** @deprecated use `isFunctionScopeBoundary` from `tsutils` */
+function isScopeBoundary(node) {
+ return (node.kind === ts.SyntaxKind.FunctionDeclaration ||
+ node.kind === ts.SyntaxKind.FunctionExpression ||
+ node.kind === ts.SyntaxKind.PropertyAssignment ||
+ node.kind === ts.SyntaxKind.ShorthandPropertyAssignment ||
+ node.kind === ts.SyntaxKind.MethodDeclaration ||
+ node.kind === ts.SyntaxKind.Constructor ||
+ node.kind === ts.SyntaxKind.ModuleDeclaration ||
+ node.kind === ts.SyntaxKind.ArrowFunction ||
+ node.kind === ts.SyntaxKind.ParenthesizedExpression ||
+ node.kind === ts.SyntaxKind.ClassDeclaration ||
+ node.kind === ts.SyntaxKind.ClassExpression ||
+ node.kind === ts.SyntaxKind.InterfaceDeclaration ||
+ node.kind === ts.SyntaxKind.GetAccessor ||
+ node.kind === ts.SyntaxKind.SetAccessor ||
+ (node.kind === ts.SyntaxKind.SourceFile && ts.isExternalModule(node)));
+}
+exports.isScopeBoundary = isScopeBoundary;
+/** @deprecated use `isBlockScopeBoundary` from `tsutils` */
+function isBlockScopeBoundary(node) {
+ return (isScopeBoundary(node) || // tslint:disable-line:deprecation
+ node.kind === ts.SyntaxKind.Block ||
+ isLoop(node) || // tslint:disable-line:deprecation
+ node.kind === ts.SyntaxKind.WithStatement ||
+ node.kind === ts.SyntaxKind.SwitchStatement ||
+ (node.parent !== undefined &&
+ (node.parent.kind === ts.SyntaxKind.TryStatement ||
+ node.parent.kind === ts.SyntaxKind.IfStatement)));
+}
+exports.isBlockScopeBoundary = isBlockScopeBoundary;
+/** @deprecated use `isIterationStatement` from `tsutils` or `typescript` */
+function isLoop(node) {
+ return (node.kind === ts.SyntaxKind.DoStatement ||
+ node.kind === ts.SyntaxKind.WhileStatement ||
+ node.kind === ts.SyntaxKind.ForStatement ||
+ node.kind === ts.SyntaxKind.ForInStatement ||
+ node.kind === ts.SyntaxKind.ForOfStatement);
+}
+exports.isLoop = isLoop;
+/**
+ * @returns Whether node is a numeric expression.
+ */
+function isNumeric(node) {
+ while (tsutils_1.isPrefixUnaryExpression(node) &&
+ (node.operator === ts.SyntaxKind.PlusToken || node.operator === ts.SyntaxKind.MinusToken)) {
+ node = node.operand;
+ }
+ return (node.kind === ts.SyntaxKind.NumericLiteral ||
+ (tsutils_1.isIdentifier(node) && (node.text === "NaN" || node.text === "Infinity")));
+}
+exports.isNumeric = isNumeric;
+/**
+ * Iterate over all tokens of `node`
+ *
+ * @description JsDoc comments are treated like regular comments and only visited if `skipTrivia` === false.
+ *
+ * @param node The node whose tokens should be visited
+ * @param skipTrivia If set to false all trivia preceeding `node` or any of its children is included
+ * @param cb Is called for every token of `node`. It gets the full text of the SourceFile and the position of the token within that text.
+ * @param filter If provided, will be called for every Node and Token found. If it returns false `cb` will not be called for this subtree.
+ *
+ * @deprecated use `forEachToken` or `forEachTokenWithTrivia` from `tsutils`
+ */
+function forEachToken(node, skipTrivia, cb, filter) {
+ // this function will most likely be called with SourceFile anyways, so there is no need for an additional parameter
+ var sourceFile = node.getSourceFile();
+ var fullText = sourceFile.text;
+ var iterateFn = filter === undefined ? iterateChildren : iterateWithFilter;
+ var handleTrivia = skipTrivia ? undefined : createTriviaHandler(sourceFile, cb);
+ iterateFn(node);
+ // this function is used to save the if condition for the common case where no filter is provided
+ function iterateWithFilter(child) {
+ if (filter(child)) {
+ return iterateChildren(child);
+ }
+ }
+ function iterateChildren(child) {
+ if (child.kind < ts.SyntaxKind.FirstNode ||
+ // for backwards compatibility to typescript 2.0.10
+ // JsxText was no Token, but a Node in that version
+ child.kind === ts.SyntaxKind.JsxText) {
+ // we found a token, tokens have no children, stop recursing here
+ return callback(child);
+ }
+ /* Exclude everything contained in JsDoc, it will be handled with the other trivia anyway.
+ * When we would handle JsDoc tokens like regular ones, we would scan some trivia multiple times.
+ * Even worse, we would scan for trivia inside the JsDoc comment, which yields unexpected results.*/
+ if (child.kind !== ts.SyntaxKind.JSDocComment) {
+ // recurse into Node's children to find tokens
+ return child.getChildren(sourceFile).forEach(iterateFn);
+ }
+ }
+ function callback(token) {
+ var tokenStart = token.getStart(sourceFile);
+ if (!skipTrivia && tokenStart !== token.pos) {
+ // we only have to handle trivia before each token, because there is nothing after EndOfFileToken
+ handleTrivia(token.pos, tokenStart, token);
+ }
+ return cb(fullText, token.kind, { tokenStart: tokenStart, fullStart: token.pos, end: token.end }, token.parent);
+ }
+}
+exports.forEachToken = forEachToken;
+function createTriviaHandler(sourceFile, cb) {
+ var fullText = sourceFile.text;
+ var scanner = ts.createScanner(sourceFile.languageVersion, false, sourceFile.languageVariant, fullText);
+ /**
+ * Scan the specified range to get all trivia tokens.
+ * This includes trailing trivia of the last token and the leading trivia of the current token
+ */
+ function handleTrivia(start, end, token) {
+ var parent = token.parent;
+ // prevent false positives by not scanning inside JsxText
+ if (!canHaveLeadingTrivia(token.kind, parent)) {
+ return;
+ }
+ scanner.setTextPos(start);
+ var position;
+ // we only get here if start !== end, so we can scan at least one time
+ do {
+ var kind = scanner.scan();
+ position = scanner.getTextPos();
+ cb(fullText, kind, { tokenStart: scanner.getTokenPos(), end: position, fullStart: start }, parent);
+ } while (position < end);
+ }
+ return handleTrivia;
+}
+/**
+ * Iterate over all comments owned by `node` or its children
+ *
+ * @deprecated use `forEachComment` from `tsutils`
+ */
+function forEachComment(node, cb) {
+ /* Visit all tokens and skip trivia.
+ Comment ranges between tokens are parsed without the need of a scanner.
+ forEachToken also does intentionally not pay attention to the correct comment ownership of nodes as it always
+ scans all trivia before each token, which could include trailing comments of the previous token.
+ Comment onwership is done right in this function*/
+ // tslint:disable-next-line:deprecation
+ return forEachToken(node, true, function (fullText, tokenKind, pos, parent) {
+ // don't search for comments inside JsxText
+ if (canHaveLeadingTrivia(tokenKind, parent)) {
+ // Comments before the first token (pos.fullStart === 0) are all considered leading comments, so no need for special treatment
+ var comments = ts.getLeadingCommentRanges(fullText, pos.fullStart);
+ if (comments !== undefined) {
+ for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) {
+ var comment = comments_1[_i];
+ cb(fullText, comment.kind, {
+ end: comment.end,
+ fullStart: pos.fullStart,
+ tokenStart: comment.pos,
+ });
+ }
+ }
+ }
+ if (canHaveTrailingTrivia(tokenKind, parent)) {
+ var comments = ts.getTrailingCommentRanges(fullText, pos.end);
+ if (comments !== undefined) {
+ for (var _a = 0, comments_2 = comments; _a < comments_2.length; _a++) {
+ var comment = comments_2[_a];
+ cb(fullText, comment.kind, {
+ end: comment.end,
+ fullStart: pos.fullStart,
+ tokenStart: comment.pos,
+ });
+ }
+ }
+ }
+ });
+}
+exports.forEachComment = forEachComment;
+/** Exclude leading positions that would lead to scanning for trivia inside JsxText */
+function canHaveLeadingTrivia(tokenKind, parent) {
+ switch (tokenKind) {
+ case ts.SyntaxKind.JsxText:
+ return false; // there is no trivia before JsxText
+ case ts.SyntaxKind.OpenBraceToken:
+ // before a JsxExpression inside a JsxElement's body can only be other JsxChild, but no trivia
+ return (parent.kind !== ts.SyntaxKind.JsxExpression ||
+ parent.parent.kind !== ts.SyntaxKind.JsxElement);
+ case ts.SyntaxKind.LessThanToken:
+ switch (parent.kind) {
+ case ts.SyntaxKind.JsxClosingElement:
+ return false; // would be inside the element body
+ case ts.SyntaxKind.JsxOpeningElement:
+ case ts.SyntaxKind.JsxSelfClosingElement:
+ // there can only be leading trivia if we are at the end of the top level element
+ return parent.parent.parent.kind !== ts.SyntaxKind.JsxElement;
+ default:
+ return true;
+ }
+ default:
+ return true;
+ }
+}
+/** Exclude trailing positions that would lead to scanning for trivia inside JsxText */
+function canHaveTrailingTrivia(tokenKind, parent) {
+ switch (tokenKind) {
+ case ts.SyntaxKind.JsxText:
+ // there is no trivia after JsxText
+ return false;
+ case ts.SyntaxKind.CloseBraceToken:
+ // after a JsxExpression inside a JsxElement's body can only be other JsxChild, but no trivia
+ return (parent.kind !== ts.SyntaxKind.JsxExpression ||
+ parent.parent.kind !== ts.SyntaxKind.JsxElement);
+ case ts.SyntaxKind.GreaterThanToken:
+ switch (parent.kind) {
+ case ts.SyntaxKind.JsxOpeningElement:
+ return false; // would be inside the element
+ case ts.SyntaxKind.JsxClosingElement:
+ case ts.SyntaxKind.JsxSelfClosingElement:
+ // there can only be trailing trivia if we are at the end of the top level element
+ return parent.parent.parent.kind !== ts.SyntaxKind.JsxElement;
+ default:
+ return true;
+ }
+ default:
+ return true;
+ }
+}
+/**
+ * Checks if there are any comments between `position` and the next non-trivia token
+ *
+ * @param text The text to scan
+ * @param position The position inside `text` where to start scanning. Make sure that this is a valid start position.
+ * This value is typically obtained from `node.getFullStart()` or `node.getEnd()`
+ */
+function hasCommentAfterPosition(text, position) {
+ return (ts.getTrailingCommentRanges(text, position) !== undefined ||
+ ts.getLeadingCommentRanges(text, position) !== undefined);
+}
+exports.hasCommentAfterPosition = hasCommentAfterPosition;
+function getEqualsKind(node) {
+ switch (node.kind) {
+ case ts.SyntaxKind.EqualsEqualsToken:
+ return { isPositive: true, isStrict: false };
+ case ts.SyntaxKind.EqualsEqualsEqualsToken:
+ return { isPositive: true, isStrict: true };
+ case ts.SyntaxKind.ExclamationEqualsToken:
+ return { isPositive: false, isStrict: false };
+ case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+ return { isPositive: false, isStrict: true };
+ default:
+ return undefined;
+ }
+}
+exports.getEqualsKind = getEqualsKind;
+function isStrictNullChecksEnabled(options) {
+ return (options.strictNullChecks === true ||
+ (options.strict === true && options.strictNullChecks !== false));
+}
+exports.isStrictNullChecksEnabled = isStrictNullChecksEnabled;
+function isNegativeNumberLiteral(node) {
+ return (tsutils_1.isPrefixUnaryExpression(node) &&
+ node.operator === ts.SyntaxKind.MinusToken &&
+ node.operand.kind === ts.SyntaxKind.NumericLiteral);
+}
+exports.isNegativeNumberLiteral = isNegativeNumberLiteral;
+/** Wrapper for compatibility with typescript@<2.3.1 */
+function isWhiteSpace(ch) {
+ // tslint:disable-next-line
+ return (ts.isWhiteSpaceLike || ts.isWhiteSpace)(ch);
+}
+exports.isWhiteSpace = isWhiteSpace;
projects / dotfiles / .git / blobdiff