Merge pull request #570 from arash16/master

Arbiter.js Type Definition

Arbiter/Arbiter-tests.ts

@@ -0,0 +1,63 @@
+// Type definitions for Arbiter.js 1.0
+// Project: http://arbiterjs.com/
+// Definitions by: Arash Shakery <https://github.com/arash16>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+// May 22 2013
+
+/// <reference path="Arbiter.d.ts" />
+
+
+
+// Publish a simple message
+Arbiter.publish('component/msg');
+
+// Subscribe to a message
+Arbiter.subscribe('component/msg', function () { });
+
+// Pass data to subscribers
+Arbiter.publish('component/msg', { "data": "value" });
+
+// Force message bubbling
+Arbiter.publish('component/msg', null, { cancelable: false });
+
+// Allow late susbcribers to be notified of past messages
+Arbiter.publish('component/msg', null, { persist: true });
+
+// Fire subscribers asynchronously
+Arbiter.publish('component/msg', null, { async: true });
+
+// Subscribe to multiple messages at once
+Arbiter.subscribe('component/msg, component/msg2', function () { });
+Arbiter.subscribe(['component/msg', 'component/msg2'], function () { });
+
+// Subscribe to multiple messages using a wildcard
+Arbiter.subscribe('component/*', function () { });
+
+// Subscribe to ALL messages
+Arbiter.subscribe('*', function () { });
+
+// Set subscriber priority
+Arbiter.subscribe('msg', { priority: 10 }, function () { });
+Arbiter.subscribe('msg', { priority: 20 }, function () { } ); // Called first!
+
+// Execute a subscriber asynchronously
+Arbiter.subscribe('msg', { async: true }, function () { });
+
+// Ignore persisted messages
+Arbiter.subscribe('msg', { persist: false }, function () { });
+
+// Set the value of "this"
+Arbiter.subscribe('msg', null, document.getElementById('x'),
+    function () {
+        this.innerHTML = "Message handled!";
+    });
+
+// Unsubscribe from messages
+var subscription_id = Arbiter.subscribe('msg', function () { });
+Arbiter.unsubscribe(subscription_id);
+
+// Re-subscribe to messages
+Arbiter.resubscribe(subscription_id);
+
+// Create a new message handler
+var MyController = Arbiter.create()

Arbiter/Arbiter.d.ts

@@ -0,0 +1,133 @@
+// Type definitions for Arbiter.js 1.0
+// Project: http://arbiterjs.com/
+// Definitions by: Arash Shakery <https://github.com/arash16>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+// May 22 2013
+
+
+declare module ArbiterDef {
+    export interface SubscribeHandler {
+        (data: any, message: string, subscriber_context: any): void;
+    }
+
+    export interface SubscribeOptions {
+        /**
+          * By default, all subscribers have a priority of 0. Higher values get higher 
+          * priority and are executed first. Negative values are allowed.
+          */
+        priority?: number;
+
+        /**
+          * A subscriber can be set to execute asynchronously, even if the message wasn't published as async.
+          */
+        async?: bool;
+
+        /**
+          * If your subscriber is not interested in any past messages that may have been 
+          * persisted, you can force them to be ignored.
+          */
+        persist?: bool;
+    }
+
+    export interface PublishOptions {
+        /**
+          * By default, subscribers can return "false" to prevent subsequent subscribers from
+          * receiving the message. By passing cancelable:false in the options, the publisher 
+          * can prevent canceling.
+          */
+        cancelable?: bool;
+
+        /**
+          * If the publishers wants subscribers to be notified even if they subscribe later, 
+          * setting the persist flag will do that.
+          */
+        persist?: bool;
+
+        /**
+          * If you wish to notify the subscribers but return from the publish() call before 
+          * the subscriber functions execute, use asynchronous mode
+          */
+        async?: bool;
+    }
+
+    export interface ArbiterStatic {
+        version: string;
+        updated_on: string;
+
+        /**
+          * Creates a separate Arbiter instance.
+          */
+        create(): ArbiterStatic;
+
+
+        /**
+          * Publishes a message to all subscribers.
+          * Returns: true on success, false if any subscriber has thrown a js exception.
+          * 
+          * @param msg Message may be in any format, but may not contain [ ,*]. A structure like a/b/c is recommended by convention, to allow messages to be categorized.
+          * @param data Pass data to subscribers that contains details about the message.
+          */
+        publish(msg: string, data?: any, options?: PublishOptions): bool;
+
+
+        /**
+          * Subscribes to messages.
+          * Returns: subscription id or [id1,id2] if subscribing to multiple messages
+          *
+          * @param msg comma separated messages or use wildcard like a/b/*
+          */
+        subscribe(msg: string, func: SubscribeHandler): any;
+
+        /**
+          * Subscribes to messages.
+          * Returns: subscription id or [id1,id2] if subscribing to multiple messages
+          *
+          * @param msg comma separated messages or use wildcard like a/b/*
+          */
+        subscribe(msg: string, options: SubscribeOptions, func: SubscribeHandler): any;
+
+        /**
+          * Subscribes to messages. Can use comma separated or wildcards in message.
+          * Returns: subscription id or [id1,id2] if subscribing to multiple messages
+          */
+        subscribe(msg: string, options: SubscribeOptions, context: any, func: SubscribeHandler): any;
+
+
+        /**
+          * Subscribes to messages.
+          * Returns: subscription id or [id1,id2] if subscribing to multiple messages
+          *
+          * @param msg comma separated messages or use wildcard like a/b/*
+          */
+        subscribe(msg: string[], func: SubscribeHandler): any;
+
+        /**
+          * Subscribes to messages.
+          * Returns: subscription id or [id1,id2] if subscribing to multiple messages
+          *
+          * @param msg comma separated messages or use wildcard like a/b/*
+          */
+        subscribe(msg: string[], options: SubscribeOptions, func: SubscribeHandler): any;
+
+        /**
+          * Subscribes to messages.
+          * Returns: subscription id or [id1,id2] if subscribing to multiple messages
+          *
+          * @param msg comma separated messages or use wildcard like a/b/*
+          */
+        subscribe(msg: string[], options: SubscribeOptions, context: any, func: SubscribeHandler): any;
+
+
+        /**
+          * Unsubscribing simply sets a flag which prevents the subscriber from executing, in case you want to re-subscribe later.
+          */
+        unsubscribe(subscription_id: number);
+
+        /**
+          * After unsubscribing, you can later re-subscribe to begin receiving messages again.
+          */
+        resubscribe(subscription_id: number);
+    }
+}
+
+declare var Arbiter: ArbiterDef.ArbiterStatic;

README.md

@@ -28,6 +28,7 @@ List of Definitions
 * [Ace Cloud9 Editor](http://ace.ajax.org/) (by [Diullei Gomes](https://github.com/Diullei))
 * [AmCharts](http://www.amcharts.com/) (by [Covobonomo](https://github.com/covobonomo/))
 * [AngularJS](http://angularjs.org) (by [Diego Vilar](https://github.com/diegovilar)) ([wiki](https://github.com/borisyankov/DefinitelyTyped/wiki/AngularJS-Definitions-Usage-Notes))
+* [Arbiter](http://arbiterjs.com/) (by [Arash Shakery](https://github.com/arash16))
 * [async](https://github.com/caolan/async) (by [Boris Yankov](https://github.com/borisyankov))
 * [Backbone.js](http://backbonejs.org/) (by [Boris Yankov](https://github.com/borisyankov))
 * [Backbone Relational](http://backbonerelational.org/) (by [Eirik Hoem](https://github.com/eirikhm))