New Method API

[kbrsh]

Moon v1 will be getting a new method API that uses actual method calls instead of instance.callMethod(). Here is what it will look like:

1. Methods will be treated as constants. Moon will no longer deoptimize m-on because it cannot infer if you will be changing the methods. In v1, Moon will enforce that all methods are constant and cannot change.
2. Methods will no longer be a part of instance.data, but instead will be stored in instance.methods. This means that you can have data and methods with the same name (although this is a bad practice).
3. Methods will be callable with:

   instance.methods.foo("Bar", 10);

   This also means that m-on will attach event listeners for methods differently, and will only deoptimize if a dynamic parameter is passed (m-on:click="foo(dynamicProperty)")

@rogierverbrugge @LeviSchuck @kokujin @trusktr @karlseguin I'd love to know your thoughts on this (you guys are pretty active on here).

[LeviSchuck]

I favor the dot calls more than string accessors.
I am cool with all methods being constant to the component, not changing between instances or current properties.
No comment on the m- stuff, as I've ended up writing render code directly with greater predictability.

[kbrsh]

Cool @LeviSchuck. I prefer them as well, and they will not be present in data anymore. I have a feeling that this change will be welcomed (I certainly like it), and am working on the changes right now.

By the way, you can use functional components for a little speed boost (if you're writing custom render functions). The way functional components work is that they can have data, props, and inserts.

This will only work for v1.0.0-pre-alpha.

Moon.extend("Functional", {
  functional: true,
  data: () => ({
    foo: "Local Data"
  }),
  props: ["bar"],
  render: function(m, context) {
    // Data AND props are available in `context.data`
    // Insert is available in `context.insert`
    return m("h1", {attrs: {}}, {dynamic: 1}, [
      m("#text", {dynamic: 1}, `Local Data: ${context.data.foo} | Props: ${context.data.bar}`)
    ]);
  }
});

[trusktr]

Why is it that instance.foo("Bar", 10); isn't possible?

[kbrsh]

@trusktr It is possible, but that would mean you can't name methods as any of Moon's internal properties.

[sudomabider]

I dig this.

[kbrsh]

@trusktr @sudomabider If you really want them on the instance (and will be careful to name them correctly), then you will be able to use this in v1:

const MoonMethods = {
  init(Moon) {
    const MoonInit = Moon.prototype.init;
    Moon.prototype.init = function() {
      const methods = this.methods;
      for(let name in methods) {
        this[name] = methods[name];
      }
      MoonInit.call(this);
    }
  }
};

Moon.use(MoonMethods);

const app = new Moon({
  methods: {
    foo() {
      alert("Foo Called!");
    }
  }
});

app.foo();

[trusktr]

What about checking against a blacklist of methods that are not allowed to be defined by the component author, throwing an error if the author tries to define a backlisted method? Is that too much?