Consider the code:

mediator.once("channel",function(){console.log(1);mediator.publish("channel");});
mediator.publish("channel");

This works infinitely though "once" is written instead of "subscribe"

A lot of functions which create an event listener allows us pass thisArg as third parameter.
IMHO current third parameter (options) is used not as frequently as thisArg.
I don't want to impose the opinion, but I really want to have this feature :-)

It seems that if I subscribe twice to the same channel with the same subscriber with the "once" method, then if I "publish", the channel will be executed twice for the subscriber !

I thought "once" would have meant :

• one subscription by subscriber, avoiding multiple subscriptions for the same subscriber.
• when published once, then unsubscribed (that part is ok).

Example :

mediator.once("test", function () { print("Hello world!"); });
mediator.once("test", function () { print("Hello world!"); });
mediator.publish("test");

...seem to print :

"Hello world!" "Hello world!"

I've got a Chaplin app I'm working on, and I'm having issues using the priority on subscriptions.... Here's a little code:

// from my "LayoutView":
mediator.subscribe('log:toggle', this.sizeViews, { priority: 9 });

// from my "LogView":
mediator.subscribe('log:toggle', this.toggleMe, { priority: 1 });

I have a console.log() in both handlers, and no matter what, the one from my Layout view is called first... I tried it at priority 0, 2 and 9... I want the one from LeftSidebar to fire first...

What am I doing wrong?

I may end up just adding a publish to the LogView stating when it's done, and the subscribe to that in my LayoutView, but that feels like the easy way out. =)

PR #31 introduced a change in behaviour which might break existing implementations of the Mediator. The change to getChannel() on the Mediator object has had an unexpected consequence.

When you have a channel named root:sub1 and you post a message to root:sub1:subA the message will bubble through the hierarchy as expected. The problem is that subscribers will no longer be able to tell the message was originally posted to root:sub1:subA.

Before the PR this worked because the publish method create the non-existing root:sub1:subA and call the subscribers with this newly created Channel object. Due to the change the subscribers will now get called with a Channel which has a namespace root:sub as this is the most specific channel we were able to find.

I am not sure if this is going to cause any problems for anyone already using the Mediator from before PR #31 was merged. One possible solution could be to push the namespace the publish method was called with into the arguments array like this:

function publish(channelName) {
  ...
  var args = Array.prototype.slice.call(arguments, 1);
  args.push(channel);
  args.push(channelName);
  channel.publish(args);
  ...
}

Can I use Mediator to publish and subscribe across different files loaded with require in node.js and browserify?

I'm using Mediator to allow multiple backbone views to subscribe to a single channel. Each of these views do something different with the data, and may be removed from the DOM at any point.

Upon removal, I am attempting to unsubscribe (via Remove) as part of the view's destruction. Calling remove while destroying one view removes all of the other view's subscriptions to the channel. I'm assuming I'm doing something wrong, or at least not properly referencing the callback I'm attempting to remove?

Is there a way to unsubscribe only one "listener" from a given channel?

If we have a few of subscribers and one of those throws an exception, our thread of execution well be interrupted.

For example:

var hub = new Mediator();
hub.on('test', function func1() { console.log(1); });
hub.on('test', function func2() { throw new Error('test error'); });
hub.on('test', function func3() { console.log(3); });

hub.trigger('test');
console.log(4);

Actual result:

1
throwing exception

Expected result:

1
3
4
and throwing exception with stacktrace

Hi,

I am using MediatorJS with requireJS modules. After a page change all my listeners will be informed and they will execute some tasks. Some tasks are async. This has the effect that this will not work constantly:

                    showLoader();

                    // Publish page change
                    mediator_.publish(
                        config_.mediator.channel.afterContentNavigation,
                        {
                            "content": $frameDoc,
                            "page": page
                        }
                    );

                    hideLoader();

As you can imagine if a components listens to the afterContentNavigation it will be triggered sure, but the hideLoader() function will may be called before the async task is completed.

Is there a way to handle such things with Mediator-JS?

I want to get the last value of 'mediator.publish()'.
like this:
mediator.publish("message", "Hello, world");
and then ,i can get 'Hello,world' by :mediator.getlastpuslish('message')

I am using require-js to load mediator.js as a dependency. When I register using any name in requirejs config, the module does not load as it gets referenced with a default name "mediator-js" as can be seen in the mediator.js source.
Can this default behavior be removed ?, so that we may reference it using any other name other than "mediator-js" , I was trying to use "mediatorjs" instead in my requirejs config.

requirejs config
requirejs.config({
baseUrl: './assets/js/',
paths: {
"jquery": 'jquery-1.12.4.min',
"jqueryui": 'jquery-ui.min',
"jquerylayout":'jquery.layout-1.4.0',
"mediator-js":'mediator/mediator' // trying to use "mediatorjs" does not link it to the module.
}
});

If I listen to 'x:y' and I emit to 'x:y:z', my listener won't trigger. However, if I add a listener for 'x:y:z', then both will trigger. Is this intended? I would expect all 'parent' channels to be visited always, regardless of any gaps in the listeners.
What is the purpose of the namespace check in Mediator.publish? It seems to be the cause.

Best regards

Let's say we have a call to

channel.publish('something', true);

And we want to know just after we want to know if the propagation has been stopped, is that normal that

this.stopped = false;

appears at the end of the publish method, instead of at the top of it? (as initialization?)

What does this for ? i dont understand
can you explain it to me?
inside the Subscriber function :
if (!(this instanceof Subscriber)) { return new Subscriber(fn, options, context); }

In Meteor, packages are exported by assigning to a global (by omitting the var keyword)*.

Please consider adding it at the top of your library. That way, it wouldn't need to be repackaged for Meteor each time you release a new version.

The standard method looks like this:

if (typeof Package !== 'undefined') {
  // Meteor
  Mediator = factory();
} else if (typeof define === 'function' && define.amd) {
  // AMD
  define('mediator-js', [], function() {
    global.Mediator = factory();
    return global.Mediator;
  });
} else if (typeof exports !== 'undefined') {
  // Node/CommonJS
  exports.Mediator = factory();
} else {
  // Browser global
  global.Mediator = factory();
}

The Package check must go on top to prevent the Node style export further down.

Thanks for considering this.

(* Behind the scenes, Meteor creates the variable in a private scope, wraps the library code in an IIFE, and finally exports the var through its own means)

I am having problems loading mediator with requirejs (2.1.15) - when using it as a requirement for some modules

define(["mediator-js"], function(mediator_) {
    console.log(mediator_);
});

returns undefined to the browser console. What am I doing wrong?

Is it possible to set the IDs of subscribers manually? Thanks

I am trying to use this (v 0.9.0) with requirejs v 2.1.2, and ran into the following issue. When loading mediator like so:

define(['mediator'], function(Mediator) {
  console.log(Mediator);
});

Mediator is undefined. Looking at the amd section, I noticed it was done differently than some other modules I'm using (mustache to be exact). I changed mediator to call requirejs properly. Here's a diff:

22c22
<   } else if(typeof root.define === 'function' && root.define.amd) {

---
>   } else if(typeof define === 'function' && define.amd) {
24,27c24
<     root.define([], function() {
<       // Export to global too, for backward compatiblity
<       root.Mediator = factory();
<     });

---
>     define(factory());

New code looks like this:

  } else if(typeof define === 'function' && define.amd) {
    // AMD
    define(factory());
  }

I'm now getting the Mediator object properly. I'm not sure if you still need to check "root.define" and "root.define.amd", but the define function should be global at this point anyways if require is there. I've tested it with this:

  } else if(typeof root.define === 'function' && root.define.amd) {
    // AMD
    root.define(factory());
  }

and it worked fine as well. I think the problem is either (or both) calling define with two arguments, the first being an empty array, and also not returning the pointer to the factory function itself as the second argument.

Can't wait to give your module a try now that I've got it loading.

EDIT Changed the define(factory) calls to define(factory()), since the return is a function to execute on define.

Here is a jsfiddle. Shows calls getting decremented even when predicate is false.
http://jsfiddle.net/kashL/7/

Looks like "called" var needs to be set to false in the for loop at line 207.

Hi,

unfortunately I didn't found any deeper documentation about priority. The documentation says that there is a priority property and you can set a integer value but there is no example or use case.

However, I would like to begin with one use case. I have one function that should be called as the last event listener since it depends on settings the previous listeners will set. Therefore it would be good to know what the default priority is? If it would be 1 I hopefully could set priority to 0 and the function would be called at the end.

However, could somebody @ajacksified tell me how to manage such situations with Mediator.js?

This works for almond

// AMD
define('mediator',[],function() {
  root.Mediator = factory();
  return root.Mediator();
});

Great module, Thank you!

Have you through of adding chaining to subscribe, once and remove methods?

E.g.

Mediator
     .subscribe('channe:one', doOne)
     .subscribe('channel:two', doTwo)
     .subscribe('channe:three', doThree)

I notice subscribe and once return the subscriber. What is the use case for this?

If this would be a positive change I'd be happy to submit a pull.

Hi, is there a way to attach a callback globaly for all publish/subscribe events?

Hi! Is there any way to use this with React ?

I am new to React so I am not sure how to make it available "globally" so that unrelated React components can communicate between them.

Hi there,

I am using your mighty Mediator in one of my projects.
It's an Angular project generated with yeoman.
I am using bower for all my dependencies and added mediator-js (v.0.9.6) in my bower.json.

When running grunt bowerInstall i get the following error:

"mediator-js was not injected in your file"

The detector looks for mediator-js.js in dependencies root folder but can not find it. (It simply does not exist)

Can you please have a look at this?

Thank you!

When using mediator.js in Dojo (it loads modules with require.js) we must use the same name you defined ("mediator-js") to instantiate it.

I think it will be better not giving it any name, so it's up to the user define it with a custom name.

If i subscribe to a channel many times but i want a callback to be called only once, a way to do this is to call unsubscribe inside the callback.

But doing this updates (logically) the _callbacks array and the loop in Publish fails because the length is checked only at the loop's start.

Is there an another/recommended way to do this ? (run a callback only once)

Thanks in advance.

I was looking at the removeSubscriber method of the Channel object and I noticed something that I can't explain.

When removing a specific subscriber you set the channel property of the subscriber to null before removing it from the array of subscribers. When all the subscribers get cleared due to the id param being null the array is simply cleared and the channel property on all the subscribers don't get reset to null.

Is there a specific reason for this or is it an oversight?

Feature Request: It should be possible to subscribe to multiple channels, e.g. separated by a ,. A example would look like: mediator.subscribe("channelOne, channelTwo", function(){}); like in the jQuery syntax.

I try to extend Mediator with a new method, but this code make an error with "this." :

Mediator.prototype = {

    subscribeBis: function(channelName){

        var myId = this.subscribe(channelName, function(data){
            console.log(myId);
        });
    }
};

var myMediator = new Mediator();
myMediator.subscribeBis("test");

Thanks for a great library.

I'm using it in a bit of a convoluted way and I'd like to have access to the Mediator constructor via the instances' prototype – would you consider either not doing Mediator.prototype = {...} or doing a reassignment afterwards?

Like this: Mediator.prototype.constructor = Mediator