diff --git a/Arbiter/Arbiter-tests.ts b/Arbiter/Arbiter-tests.ts new file mode 100644 index 000000000..bcb359456 --- /dev/null +++ b/Arbiter/Arbiter-tests.ts @@ -0,0 +1,63 @@ +// Type definitions for Arbiter.js 1.0 +// Project: http://arbiterjs.com/ +// Definitions by: Arash Shakery +// Definitions: https://github.com/borisyankov/DefinitelyTyped +// May 22 2013 + +/// + + + +// 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() diff --git a/Arbiter/Arbiter.d.ts b/Arbiter/Arbiter.d.ts new file mode 100644 index 000000000..d80661e58 --- /dev/null +++ b/Arbiter/Arbiter.d.ts @@ -0,0 +1,133 @@ +// Type definitions for Arbiter.js 1.0 +// Project: http://arbiterjs.com/ +// Definitions by: Arash Shakery +// 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; diff --git a/README.md b/README.md index a55e99562..7ed04dc14 100644 --- a/README.md +++ b/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))