How to use the forEachChild function from typescript

index.js

GitHub: surveyjs/surveyjs-doc-generator

475
476
477
478
479
480
481
482
483
484
var isOptions = curClass.name.indexOf("IOn") === 0;
if (!isOptions) {
    outputClasses.push(curClass);
}
curJsonName = null;
ts.forEachChild(node, visitClassNode);
if (isOptions)
    return;
if (!curJsonName)
    return;

3

4

4

+ 35 other calls in file

widgets.js

GitHub: iamwjun/explore-webpack

154
155
156
157
158
159
160
161
162
163

const dependencies = [];
const sourceFile = program.getSourceFile(filePath);

if (sourceFile) {
  ts.forEachChild(sourceFile, (node) => {
    if (
      ts.isImportDeclaration(node) ||
      ts.isExportDeclaration(node) ||
      ts.isImportEqualsDeclaration(node) ||

0

0

1

+ 18 other calls in file

typedefRule.js

GitHub: cuongnqph06515/node_modules

115
116
117
118
119
120
121
122
123
124
                break;
            }
            case ts.SyntaxKind.VariableDeclaration:
                _this.checkVariableDeclaration(node);
        }
        return ts.forEachChild(node, cb);
    };
    return ts.forEachChild(sourceFile, cb);
};
TypedefWalker.prototype.checkArrowFunction = function (_a) {

0

0

1

+ 5 other calls in file

variableNameRule.js

GitHub: cuongnqph06515/node_modules

104
105
106
107
108
109
110
111
112
113
        return ruleArguments.indexOf(name) !== -1;
    }
}
function walk(ctx) {
    var options = ctx.options, sourceFile = ctx.sourceFile;
    return ts.forEachChild(sourceFile, function cb(node) {
        switch (node.kind) {
            case ts.SyntaxKind.BindingElement: {
                var _a = node, initializer = _a.initializer, name = _a.name, propertyName = _a.propertyName;
                if (name.kind === ts.SyntaxKind.Identifier) {

0

0

1

+ 5 other calls in file

noAsyncWithoutAwaitRule.js

GitHub: SumeetOutlook/sumeet-practice

65
66
67
68
69
70
71
72
73
74
        !functionBlockHasAwait(node.body) &&
        !functionBlockHasReturn(node.body)) {
        reportFailureIfAsyncFunction(node);
    }
};
return ts.forEachChild(context.sourceFile, function visitNode(node) {
    if (tsutils.isArrowFunction(node) ||
        tsutils.isFunctionDeclaration(node) ||
        tsutils.isFunctionExpression(node) ||
        tsutils.isMethodDeclaration(node)) {

0

0

1

+ 1021 other calls in file

noUnsafeAnyRule.js

GitHub: SumeetOutlook/sumeet-practice

257
258
259
260
261
262
263
264
265
266
                this.checkContextualType(node.expression));
    }
    if (tsutils_1.isTypeNodeKind(node.kind) || tsutils_1.isTokenKind(node.kind)) {
        return false;
    }
    return ts.forEachChild(node, this.visitNodeCallback);
};
NoUnsafeAnyWalker.prototype.check = function (node) {
    if (!isNodeAny(node, this.checker)) {
        return false;

0

0

1

+ 525 other calls in file

newlinePerChainedCallRule.js

GitHub: SumeetOutlook/sumeet-practice

57
58
59
60
61
62
63
64
65
66
                hasChildCall(node.expression)) {
                _this.addFailure(node.expression.name.pos - 1, node.expression.name.end, Rule.FAILURE_STRING);
            }
            return ts.forEachChild(node, checkForSameLine);
        };
        return ts.forEachChild(sourceFile, checkForSameLine);
    };
    return NewlinePerChainedCallWalker;
}(Lint.AbstractWalker));
function hasChildCall(node) {

0

0

1

+ 1795 other calls in file

newParensRule.js

GitHub: SumeetOutlook/sumeet-practice

42
43
44
45
46
47
48
49
50
51
    Rule.FAILURE_STRING = "Parentheses are required when invoking a constructor";
    return Rule;
}(Lint.Rules.AbstractRule));
exports.Rule = Rule;
function walk(ctx) {
    return ts.forEachChild(ctx.sourceFile, function cb(node) {
        if (node.kind === ts.SyntaxKind.NewExpression &&
            node.arguments === undefined) {
            ctx.addFailureAtNode(node, Rule.FAILURE_STRING);
        }

0

0

1

+ 1833 other calls in file

no-internal-barrel-imports.js

GitHub: iTwin/eslint-plugin

215
216
217
218
219
220
221
222
223
224
// prettier-ignore
if (ignoredBarrelModules.includes(OsPaths.normalize(importedModule.fileName)))
  return;

let containsReExport = false;
ts.forEachChild(importedModule, (child) => {
  const potentialReExport =
    ts.isExportDeclaration(child) &&
    child.moduleSpecifier !== undefined &&
    !child.isTypeOnly;

0

0

2

+ 19 other calls in file

typeLiteralDelimiterRule.js

GitHub: saleem1989/SalotimeMini

67
68
69
70
71
72
73
74
75
76
var sourceFile = ctx.sourceFile, options = ctx.options;
ts.forEachChild(sourceFile, function cb(node) {
    if (tsutils_1.isTypeLiteralNode(node)) {
        check(node);
    }
    ts.forEachChild(node, cb);
});
function check(node) {
    node.members.forEach(function (member, idx) {
        var end = member.end - 1;

0

0

1

unnecessaryConstructorRule.js

GitHub: SumeetOutlook/sumeet-practice

125
126
127
128
129
130
131
132
        }
        else {
            ts.forEachChild(node, callback);
        }
    };
    return ts.forEachChild(context.sourceFile, callback);
}
var templateObject_1, templateObject_2;

0

0

1

+ 199 other calls in file

noUnnecessaryQualifierRule.js

GitHub: SumeetOutlook/sumeet-practice

47
48
49
50
51
52
53
54
55
56
    return Rule;
}(Lint.Rules.TypedRule));
exports.Rule = Rule;
function walk(ctx, checker) {
    var namespacesInScope = [];
    ts.forEachChild(ctx.sourceFile, cb);
    function cb(node) {
        switch (node.kind) {
            case ts.SyntaxKind.ModuleDeclaration:
            case ts.SyntaxKind.EnumDeclaration:

0

0

1

+ 1043 other calls in file

jsxSafeConditionalsRule.js

GitHub: Sonarqube-Testing/sonar-typescript-test

150
151
152
153
154
155
156
157
158
    }


    return ts.forEachChild(node, cb)
  }


  return ts.forEachChild(ctx.sourceFile, cb)
}

0

0

0

+ 2193 other calls in file

TypeScriptLinkGenerator.js

GitHub: MichiSpebach/mammutmap

47
48
49
50
51
52
53
54
55
56
    const importPaths = extractImportPaths(sourceFile);
    await addLinks(box, importPaths);
}
function extractImportPaths(sourceFile) {
    const importPaths = [];
    ts.forEachChild(sourceFile, node => {
        if (ts.isImportDeclaration(node)) {
            let importPath = node.moduleSpecifier.getText(sourceFile);
            importPaths.push(importPath);
        }

0

0

1

+ 3 other calls in file

binaryExpressionOperandOrderRule.js

GitHub: SumeetOutlook/sumeet-practice

44
45
46
47
48
49
50
51
52
53
    Rule.FAILURE_STRING = "Literal expression should be on the right-hand side of a binary expression.";
    return Rule;
}(Lint.Rules.AbstractRule));
exports.Rule = Rule;
function walk(ctx) {
    ts.forEachChild(ctx.sourceFile, function cb(node) {
        if (tsutils_1.isBinaryExpression(node) &&
            isLiteral(node.left) &&
            !isLiteral(node.right) &&
            !isAllowedOrderedOperator(node)) {

0

0

1

arrowParensRule.js

GitHub: SumeetOutlook/sumeet-practice

77
78
79
80
81
82
83
84
85
86
                ]);
            }
        }
        return ts.forEachChild(node, cb);
    }
    return ts.forEachChild(ctx.sourceFile, cb);
}
function parensAreOptional(node) {
    return (node.parameters.length === 1 &&
        node.typeParameters === undefined &&

0

0

1

completedDocsRule.js

GitHub: SumeetOutlook/sumeet-practice

256
257
258
259
260
261
262
263
264
265
exports.Rule = Rule;
var modifierAliases = {
    export: "exported",
};
function walk(context) {
    return ts.forEachChild(context.sourceFile, cb);
    function cb(node) {
        switch (node.kind) {
            case ts.SyntaxKind.ClassDeclaration:
                checkNode(node, exports.ARGUMENT_CLASSES);

0

0

1

preferInlineDecoratorRule.js

GitHub: SumeetOutlook/sumeet-practice

213
214
215
216
217
218
219
220
221
222
};
var walk = function (walkContext) {
    var sourceFile = walkContext.sourceFile;
    var callback = function (node) {
        callbackHandler(walkContext, node);
        typescript_1.forEachChild(node, callback);
    };
    typescript_1.forEachChild(sourceFile, callback);
};
var templateObject_1;

0

0

1

contextualDecoratorRule.js

GitHub: SumeetOutlook/sumeet-practice

80
81
82
83
84
85
86
87
    var sourceFile = walkContext.sourceFile;
    var callback = function (node) {
        callbackHandler(walkContext, node);
        typescript_1.forEachChild(node, callback);
    };
    typescript_1.forEachChild(sourceFile, callback);
};
var templateObject_1;

0

0

1

make_transform.js

GitHub: SumeetOutlook/sumeet-practice

80
81
82
83
84
85
86
    var _a;
    if (((_a = node.decorators) === null || _a === void 0 ? void 0 : _a.length) === 0) {
        // tslint:disable-next-line:no-any
        node.decorators = undefined;
    }
    ts.forEachChild(node, node => cleanupDecorators(node));
}

0

0

1