fx-shared-instance.html

<!--
    Implements the monostate pattern. Allows notifying all instances of a
    given instanceType (tagName by default) of some event.

    Note that the default of tagName is not friendly to subclassing so you
    should specify an explicit instanceType if you expect your component to
    be subclassed.

    Usage:

    <polymer-element name="app-example" extends="fx-shared-instance">
        <template>
            ..
        </template>
        <script>
            Polymer({
                doStuff: function() {
                    this.notifyInstances("updateRect", {
                        data: // ...
                    });
                },
                updateRect: function(data) {
                    // do something with the notification.
                },
            });
        </script>
    </polymer-element>
-->
<link href="../polymer/polymer.html" rel="import">

<polymer-element name="fx-shared-instance" constructor="FxSharedInstance">
<script>
"use strict";
(function() {
    var instances = {};

    function registerInstance(object, type) {
        instances[type] = instances[type] || [];
        instances[type].add(object);
    }

    function unregisterInstance(object, type) {
        if (!instances[type])
            return;
        instances[type].remove(object);
    }

    function getInstances(type) {
        return instances[type] || [];
    }

    function notify(type, method, data) {
        var receivers = getInstances(type);
        for (var i = 0; i < receivers.length; ++i)
            notifyInternal(receivers[i], type, method, data);
    }

    // FIXME: Hack for v8 since it can't optimize functions with try/catch.
    function notifyInternal(receiver, type, method, data) {
        try {
            if (typeof receiver[method] == "function")
                receiver[method](data);
        } catch (e) {
            console.log("Failed notification", type, method, e);
        }
    }

    function notifyAsync(type, method, data) {
        return Promise.resolve().then(function() {
            notify(type, method, data);
        });
    }

    Polymer({
        created: function() {
            this.instanceType = this.tagName.toLowerCase();
        },
        attached: function() {
            registerInstance(this, this.instanceType);
        },
        detached: function() {
            unregisterInstance(this, this.instanceType);
        },
        notifyInstances: function(method, data) {
            notify(this.instanceType, method, data);
        },
        notifyInstancesAsync: function(method, data) {
            return notifyAsync(this.instanceType, method, data);
        },
        getInstances: function() {
            return getInstances(this.instanceType);
        },
    });

    document.addEventListener("polymer-ready", function() {
        // Static API
        FxSharedInstance.notify = notify;
        FxSharedInstance.notifyAsync = notifyAsync;
        FxSharedInstance.getInstances = getInstances;
    });
})();
</script>
</polymer-element>