What is a good use-case for the ES2015 Static Methods?

It is common to use static methods as an alternative constructor.
Moreover, they are frequently used in order to define utility and helper functions.

Take a look at this quick easy example:

class Bird {
    constructor({ color = "red" } = {}) {
        this.color = color;
    }
    static compareBirds(first, second) {
        return (first.color === second.color);
    }
}

let redBird = new Bird;
let blueBird = new Bird({"color": "blue"});

console.log(Bird.compareBirds(redBird, blueBird)); // false
console.log(Bird.compareBirds(redBird, redBird)); // true

As you can spot, static method compareBirds() provides us with an ability to compare colors of already instantiated birds.
Of course it is a simplified example, but likewise, you can create a method for bird sorting. This method will also act as a helper function for your app.

Don't forget about new ...rest parameter, which might be helpful in case you want to sort many birds! :)

Whether or not there's EVER a use case for classes in ES6 is controversial ... https://medium.com/javascript-scene/common-misconceptions-about-inheritance-in-javascript-d5d9bab29b0a#.rgk7ty7ed Remember that class is syntactic sugar - you're just creating an object (which can be used as a prototype for other objects).

The best use case for static methods in other languages is to group functions (that aren't really object-oriented and don't work on objects) together into classes for convenience and to create "alternate" constructors that are associated with the class their intended to construct. In JavaScript, you don't need any of this, but if you code in the classical pattern long enough you'll no doubt discover a use-case for them on your own (until then I wouldn't worry about it).

React has a good use case of a static method.

Not going into details of how react works, a React Component uses PropTypes, an object that helps with validation of data coming into it. In ES6 you can declare it in two ways.

// adding it to the class outside of it
class SavedColors extends React.Component {
// react stuff
}

SavedColors.PropTypes = {
        colors: React.PropTypes.objectOf(React.PropTypes.number).isRequired,
        saved: React.PropTypes.bool.isRequired,
        selectColor: React.PropTypes.func.isRequired,
        isOpen: React.PropTypes.bool.isRequired
}

// adding it as a static method to the class
class SavedColors extends React.Component {
    constructor() {
       // react stuff
    }
    static PropTypes = {
        colors: React.PropTypes.objectOf(React.PropTypes.number).isRequired,
        saved: React.PropTypes.bool.isRequired,
        selectColor: React.PropTypes.func.isRequired,
        isOpen: React.PropTypes.bool.isRequired
    };
 // more react stuff
}

Basically you achieve the same thing but I think doing in the class itself is cleaner.