@fimbul/mimir - npm Package Compare versions

Comparing version 0.10.0-dev.20180517 to 0.10.0

package.json

 {
   "name": "@fimbul/mimir",
-  "version": "0.10.0-dev.20180517",
+  "version": "0.10.0",
   "description": "Core rules of the Fimbullinter project",
@@ -28,3 +28,3 @@ "main": "recommended.yaml",
   "dependencies": {
-    "@fimbul/ymir": "0.9.0",
+    "@fimbul/ymir": "^0.9.0",
     "chalk": "^2.3.2",
@@ -37,4 +37,3 @@ "debug": "^3.1.0",
     "typescript": "*"
-  },
-  "devDependencies": {}
+  }
 }

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

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

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

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

src/rules/ban-dom-globals.d.ts

@@ -5,4 +5,4 @@ import { TypedRule } from '@fimbul/ymir';
     apply(): void;
-    private isDomGlobal(declaration, name);
-    private isWindowProperty(sourceFile, name);
+    private isDomGlobal;
+    private isWindowProperty;
 }

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);
+    private getLiteralValue;
 }

src/rules/no-duplicate-spread-property.d.ts

@@ -6,5 +6,5 @@ import { TypedRule, RuleSupportsContext } from '@fimbul/ymir';
     apply(): void;
-    private checkObject({properties});
-    private getPropertyInfo(property);
-    private getPropertyInfoFromSpread(node);
+    private checkObject;
+    private getPropertyInfo;
+    private getPropertyInfoFromSpread;
 }

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

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

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

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

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-unassigned-variable.d.ts

@@ -5,3 +5,3 @@ import { AbstractRule } from '@fimbul/ymir';
     apply(): void;
-    private checkDeclaration(node);
+    private checkDeclaration;
 }

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-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-declare.d.ts

 import { AbstractRule } from '@fimbul/ymir';
 export declare class Rule extends AbstractRule {
     apply(): void;
-    private checkStatements(block);
-    private checkModule(node);
-    private shouldCheck(node);
+    private checkStatements;
+    private checkModule;
+    private shouldCheck;
 }

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

 import { AbstractRule } from '@fimbul/ymir';
 export declare class Rule extends AbstractRule {
     apply(): void;
-    private checkObjectDestructuring(node);
-    private checkBindingPattern(node, getPropName);
-    private checkFunctionParameters(parameters);
-    private fail(node, makeOptional?);
-    private removeUndefinedFromType(type);
+    private checkObjectDestructuring;
+    private checkBindingPattern;
+    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/parameter-properties.d.ts

@@ -8,3 +8,3 @@ import { ConfigurableRule } from '@fimbul/ymir';
     WhenPossible = 1,
-    Consistent = 2,
+    Consistent = 2
 }
@@ -16,3 +16,3 @@ export declare class Rule extends ConfigurableRule<Options> {
     apply(): void;
-    private checkConstructorParameters(construct);
+    private checkConstructorParameters;
 }

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-namespace-keyword.d.ts

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

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

 import { TypedRule } from '@fimbul/ymir';
 export declare class Rule extends TypedRule {
     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/return-never-call.d.ts

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

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;
 }

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

Worsened metrics

Total package byte prevSize

333061

decreased by-0.25%

Dependency changes

• Updated@fimbul/ymir@^0.9.0