@fimbul/mimir - npm Package Compare versions

Comparing version 0.7.0-dev.20180325 to 0.7.0-dev.20180326

package.json

 {
   "name": "@fimbul/mimir",
-  "version": "0.7.0-dev.20180325",
+  "version": "0.7.0-dev.20180326",
   "description": "Core rules of the Fimbullinter project",
@@ -5,0 +5,0 @@ "main": "recommended.yaml",

src/rules/await-async-result.d.ts

 import { TypedRule } from '@fimbul/ymir';
 export declare class Rule extends TypedRule {
     apply(): void;
-    private iterate(wrap, end);
-    private visitNode(wrap);
+    private iterate;
+    private visitNode;
 }

src/rules/await-only-promise.d.ts

 import { TypedRule } from '@fimbul/ymir';
 export declare class Rule extends TypedRule {
     apply(): void;
-    private isPromiseLike(node);
-    private isThenable(type, node);
-    private isAsyncIterable(node);
-    private hasSymbolAsyncIterator(type);
+    private isPromiseLike;
+    private isThenable;
+    private isAsyncIterable;
+    private hasSymbolAsyncIterator;
 }

src/rules/generator-require-yield.d.ts

@@ -5,6 +5,6 @@ import { AbstractRule } from '@fimbul/ymir';
     apply(): void;
-    private iterate(wrap, end);
-    private visitNode(wrap);
-    private shouldFail();
-    private fail({asteriskToken, name});
+    private iterate;
+    private visitNode;
+    private shouldFail;
+    private fail;
 }

src/rules/no-duplicate-case.d.ts

 import { AbstractRule } from '@fimbul/ymir';
 export declare class Rule extends AbstractRule {
     apply(): void;
-    private getLiteralValue(node, cb);
+    private getLiteralValue;
 }

src/rules/no-inferred-empty-object.d.ts

@@ -5,8 +5,8 @@ import { TypedRule } from '@fimbul/ymir';
     apply(): void;
-    private checkCallExpression(node);
-    private checkNewExpression(node);
-    private checkSignature(signature, declaration, node);
-    private checkInferredTypeParameters(signature, typeParameters, node);
-    private scannerFallback(signature, typeParameters, node);
-    private handleEmptyTypeParameter(typeParameter, node);
+    private checkCallExpression;
+    private checkNewExpression;
+    private checkSignature;
+    private checkInferredTypeParameters;
+    private scannerFallback;
+    private handleEmptyTypeParameter;
 }

src/rules/no-inferred-empty-object.js

@@ -15,8 +15,14 @@ "use strict";
         for (const node of this.context.getFlatAst()) {
-            if (node.kind === ts.SyntaxKind.CallExpression && node.typeArguments === undefined) {
+            if (node.kind === ts.SyntaxKind.CallExpression) {
+                if (node.typeArguments === undefined)
+                    this.checkCallExpression(node);
+            }
+            else if (node.kind === ts.SyntaxKind.NewExpression) {
+                if (node.typeArguments === undefined)
+                    this.checkNewExpression(node);
+            }
+            else if ((node.kind === ts.SyntaxKind.JsxOpeningElement || node.kind === ts.SyntaxKind.JsxSelfClosingElement) &&
+                node.typeArguments === undefined) {
                 this.checkCallExpression(node);
             }
-            else if (node.kind === ts.SyntaxKind.NewExpression && node.typeArguments === undefined) {
-                this.checkNewExpression(node);
-            }
         }
@@ -23,0 +29,0 @@ }

src/rules/no-misused-generics.d.ts

@@ -5,4 +5,4 @@ import { AbstractRule } from '@fimbul/ymir';
     apply(): void;
-    private checkTypeParameters(typeParameters, signature);
-    private isConstrainedByOtherTypeParameter(current, all);
+    private checkTypeParameters;
+    private isConstrainedByOtherTypeParameter;
 }

src/rules/no-unreachable-code.d.ts

 import { AbstractRule } from '@fimbul/ymir';
 export declare class Rule extends AbstractRule {
     apply(): void;
-    private checkBlock(node);
-    private checkIfStatement(node);
-    private checkConstantIterationCondition(node);
-    private report(node);
+    private checkBlock;
+    private checkIfStatement;
+    private checkConstantIterationCondition;
+    private report;
 }

src/rules/no-unstable-api-use.d.ts

 import { TypedRule } from '@fimbul/ymir';
 export declare class Rule extends TypedRule {
     apply(): void;
-    private checkObjectDestructuring(node);
-    private checkSignature(node);
-    private checkObjectBindingPattern(node);
-    private checkElementAccess(node);
-    private checkDynamicPropertyAccess(type, keyType, node);
-    private checkSymbol(symbol, node, name);
-    private checkStability<T, U, V>(s, node, hint, descr);
+    private checkObjectDestructuring;
+    private checkSignature;
+    private checkObjectBindingPattern;
+    private checkElementAccess;
+    private checkDynamicPropertyAccess;
+    private checkSymbol;
+    private checkStability;
 }

src/rules/no-unused-expression.d.ts

@@ -11,4 +11,4 @@ import { ConfigurableRule } from '@fimbul/ymir';
     apply(): void;
-    private checkNode(expr, errorNode?);
-    private isUsed(node);
+    private checkNode;
+    private isUsed;
 }

src/rules/no-unused-label.d.ts

@@ -5,5 +5,5 @@ import { AbstractRule } from '@fimbul/ymir';
     apply(): void;
-    private iterate(wrap, end);
-    private visitNode(wrap);
-    private fail(statement);
+    private iterate;
+    private visitNode;
+    private fail;
 }

src/rules/no-useless-assertion.d.ts

@@ -5,7 +5,7 @@ import { TypedRule } from '@fimbul/ymir';
     apply(): void;
-    private checkDefiniteAssignmentAssertion(node);
-    private checkDefiniteAssignmentAssertionProperty(node);
-    private checkNonNullAssertion(node);
-    private checkTypeAssertion(node);
-    private getSafeContextualType(node);
+    private checkDefiniteAssignmentAssertion;
+    private checkDefiniteAssignmentAssertionProperty;
+    private checkNonNullAssertion;
+    private checkTypeAssertion;
+    private getSafeContextualType;
 }

src/rules/no-useless-initializer.d.ts

 import { AbstractRule } from '@fimbul/ymir';
 export declare class Rule extends AbstractRule {
     apply(): void;
-    private checkFunctionParameters(parameters);
-    private fail(node, makeOptional?);
-    private removeUndefinedFromType(type);
+    private checkFunctionParameters;
+    private fail;
+    private removeUndefinedFromType;
 }

src/rules/no-useless-predicate.d.ts

@@ -5,11 +5,11 @@ import { TypedRule } from '@fimbul/ymir';
     apply(): void;
-    private checkSwitch(node);
-    private checkCondition(node);
-    private checkNode(node);
-    private maybeFail(node, result);
-    private isTruthyFalsy(node);
-    private isConstantComparison(left, right, operator);
-    private checkEquals(left, right, equals);
-    private nullAwarePredicate(type, predicate);
-    private executePredicate(type, predicate);
+    private checkSwitch;
+    private checkCondition;
+    private checkNode;
+    private maybeFail;
+    private isTruthyFalsy;
+    private isConstantComparison;
+    private checkEquals;
+    private nullAwarePredicate;
+    private executePredicate;
 }

src/rules/prefer-for-of.d.ts

@@ -5,7 +5,7 @@ import { TypedRule } from '@fimbul/ymir';
     apply(): void;
-    private checkForStatement(node);
-    private isIterationPossible(type);
-    private isIterationProtocolAvailable();
-    private isArray(type);
-    private isDeclaredInDefaultLib(node);
+    private checkForStatement;
+    private isIterationPossible;
+    private isIterationProtocolAvailable;
+    private isArray;
+    private isDeclaredInDefaultLib;
 }

src/rules/prefer-number-isnan.d.ts

@@ -6,3 +6,3 @@ import { TypedRule, RuleSupportsContext } from '@fimbul/ymir';
     apply(): void;
-    private isNumberLikeType(type);
+    private isNumberLikeType;
 }

src/rules/prefer-object-spread.d.ts

 import { TypedRule } from '@fimbul/ymir';
 export declare class Rule extends TypedRule {
     apply(): void;
-    private isSpreadableObject(node);
+    private isSpreadableObject;
 }

src/rules/try-catch-return-await.d.ts

@@ -5,4 +5,4 @@ import { TypedRule } from '@fimbul/ymir';
     apply(): void;
-    private visitStatement(node);
-    private checkReturnExpression(node);
+    private visitStatement;
+    private checkReturnExpression;
 }

src/rules/typecheck.d.ts

 import { TypedRule } from '@fimbul/ymir';
 export declare class Rule extends TypedRule {
     apply(): void;
-    private addDiagnostic(diagnostic);
+    private addDiagnostic;
 }

No alert changes

Improved metrics

Lines of code

2649

increased by0.23%

Worsened metrics

Total package byte prevSize

224628

decreased by-4.27%

No dependency changes