Class Controller
Implements
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Controller(key): Controller Constructor.
+This
+Controllerimplementation is a Multiton, +so you should not call the constructor +directly, but instead call the static Factory method, +passing the unique key for this instance +Controller.getInstance(multitonKey)Parameters
- key: string
Returns Controller
Properties
Protectedcommand
Mapping of Notification names to Command factories
+Protectedmultiton
The Multiton Key for this Core
+Protected Optionalview
Local reference to View
+Protected StaticMULTITON_
Message Constants
+Protected Staticinstance
Multiton Instances
+ Methods
execute
- execute
Command(notification): void If a
+Commandhas previously been registered +to handle the givenNotification, then it is executed.Parameters
- notification: INotification
The notification containing the data or command details needed for execution.
+
Returns void
- notification: INotification
has
Protectedinitialize
- initialize
Controller(): void Initialize the Multiton
+Controllerinstance.Called automatically by the constructor.
+Note that if you are using a subclass of
+View+in your application, you should also subclassController+and override theinitializeControllermethod in the +following way:
+ +// ensure that the Controller is talking to my View implementation
initializeController() {
this.view = MyView.getInstance("ViewTestKey1", (key: string) => new View(key));
} +Returns void
register
- register
Command(notificationName, factory): void Register a particular
+Commandclass as the handler +for a particularNotification.If an
+Commandhas already been registered to +handleNotifications with this name, it is no longer +used, the newCommandis used instead.The Observer for the new Command is only created if this the +first time a Command has been registered for this Notification name.
+Parameters
Returns void
remove
Staticget
- get
Instance(key, factory): IController
+ControllerMultiton Factory method.Parameters
- key: string
The key used to identify the controller instance.
+ - factory: ((key: string) => IController)
A factory function that creates a new instance of the controller if one does not already exist for the specified key.
+- (key): IController
Parameters
- key: string
Returns IController
Returns IController
The controller instance associated with the given key.
+- key: string
Staticremove
Class Facade
A base Multiton Facade implementation.
Implements
Index
Constructors
Properties
Methods
Properties
Protected Optionalcontroller
Reference to Controller
+Protected Optionalmodel
Reference to Model
+Protectedmultiton
The Multiton Key for this Core
+Protected Optionalview
Reference to View
+Protected StaticMULTITON_
Message Constants
+Protected Staticinstance
Multiton Instances
+ Methods
has
has
has
Protectedinitialize
- initialize
Controller(): void Initialize the
+Controller.Called by the
+initializeFacademethod. +Override this method in your subclass ofFacade+if one or both of the following are true:-
+
- You wish to initialize a different
Controller.
+ - You have
Commandsto register with theControllerat startup.`.
+
If you don't want to initialize a different
+Controller, +callsuper.initializeController()at the beginning of your +method, then registerCommands.Returns void
- You wish to initialize a different
Protectedinitialize
Protectedinitialize
- initialize
Model(): void Initialize the
+Model.Called by the
+initializeFacademethod. +Override this method in your subclass ofFacade+if one or both of the following are true:-
+
- You wish to initialize a different
Model.
+ - You have
Proxys to register with the Model that do not +retrieve a reference to the Facade at construction time.`
+
If you don't want to initialize a different
+Model, +callsuper.initializeModel()at the beginning of your +method, then registerProxys.Note: This method is rarely overridden; in practice you are more +likely to use a
+Commandto create and registerProxys +with theModel, sinceProxys with mutable data will likely +need to sendNotifications and thus will likely want to fetch a reference to +theFacadeduring their construction.Returns void
- You wish to initialize a different
initialize
- initialize
Notifier(key): void Set the Multiton key for this facade instance.
+Not called directly, but instead from the +constructor when getInstance is invoked. +It is necessary to be public in order to +implement Notifier.
+Parameters
- key: string
The unique key to identify this instance of the notifier.
+
Returns void
- key: string
Protectedinitialize
- initialize
View(): void Initialize the
+View.Called by the
+initializeFacademethod. +Override this method in your subclass ofFacade+if one or both of the following are true:-
+
- You wish to initialize a different
View.
+ - You have
Observersto register with theView
+
If you don't want to initialize a different
+View, +callsuper.initializeView()at the beginning of your +method, then registerMediatorinstances.Note: This method is rarely overridden; in practice you are more +likely to use a
+Commandto create and registerMediators +with theView, sinceMediatorinstances will need to send +Notifications and thus will likely want to fetch a reference +to theFacadeduring their construction.Returns void
- You wish to initialize a different
notify
- notify
Observers(notification): void Notify
+Observers.This method is left public mostly for backward +compatibility, and to allow you to send custom +notification classes using the facade.
+Usually you should just call
+sendNotification+and pass the parameters, never having to +construct the notification yourself.Parameters
- notification: INotification
The notification to be sent to observers.
+
Returns void
- notification: INotification
register
register
- register
Mediator(mediator): void Register a
+Mediatorwith theView.Parameters
- mediator: IMediator
The mediator instance to be registered.
+
Returns void
- mediator: IMediator
register
- register
Proxy(proxy): void Register a
+Proxywith theModelby name.Parameters
- proxy: IProxy
The proxy instance to be registered.
+
Returns void
- proxy: IProxy
remove
remove
remove
retrieve
retrieve
send
- send
Notification(notificationName, body?, type?): void Create and send an
+Notification.Keeps us from having to construct new notification +instances in our implementation code.
+Parameters
- notificationName: string
The name of the notification to be sent.
+ Optionalbody: anyOptional data to be included with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Staticget
Statichas
Staticremove
Class MacroCommand
A base Command implementation that executes other Commands.
A MacroCommand maintains a list of
+Command Class references called SubCommands.
When execute is called, the MacroCommand
+instantiates and calls execute on each of its SubCommands turn.
+Each SubCommand will be passed a reference to the original
+Notification that was passed to the MacroCommand's
+execute method.
Unlike SimpleCommand, your subclass
+should not override execute, but instead, should
+override the initializeMacroCommand method,
+calling addSubCommand once for each SubCommand
+to be executed.
Hierarchy (view full)
- SimpleCommand
- MacroCommand
Index
Constructors
constructor
- new
Macro Command(): MacroCommand Constructor.
+You should not need to define a constructor, +instead, override the
+initializeMacroCommand+method.If your subclass does define a constructor, be +sure to call
+super().Returns MacroCommand
Properties
Protectedmultiton
The Multiton Key for this app
+Protected StaticMULTITON_
Message Constants
+ Methods
Protectedadd
execute
- execute(notification): void
Execute this
+MacroCommand'sSubCommands.The
+SubCommandswill be called in First In/First Out (FIFO) +order.Parameters
- notification: INotification
The notification containing the data or command details to be processed.
+
Returns void
- notification: INotification
initialize
- initialize
Macro Command(): void Initialize the
+MacroCommand.In your subclass, override this method to +initialize the
+MacroCommand'sSubCommand+list withCommandclass references like +this:
+ +// Initialize MyMacroCommand
initializeMacroCommand() {
this.addSubCommand(() => new app.FirstCommand());
this.addSubCommand(() => new app.SecondCommand());
this.addSubCommand(() => new app.ThirdCommand());
} +Note that
+SubCommands may be anyCommandimplementor, +MacroCommands orSimpleCommandsare both acceptable.Returns void
initialize
- initialize
Notifier(key): void Initialize this Notifier instance.
+This is how a Notifier gets its multitonKey. +Calls to sendNotification or to access the +facade will fail until after this method +has been called.
+Mediators, Commands or Proxies may override +this method in order to send notifications +or access the Multiton Facade instance as +soon as possible. They CANNOT access the facade +in their constructors, since this method will not +yet have been called.
+Parameters
- key: string
the multitonKey for this Notifier to use
+
Returns void
- key: string
send
- send
Notification(notificationName, body?, type?): void Create and send an
+Notification.Keeps us from having to construct new Notification +instances in our implementation code.
+Parameters
- notificationName: string
The name of the notification to be sent.
+ Optionalbody: anyOptional data to be included with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Class Mediator
A base Mediator implementation.
Hierarchy (view full)
- Notifier
- Mediator
Implements
Index
Constructors
Properties
Accessors
Methods
Properties
Protected Readonly_name
the mediator name
+Protected Optional_view
The view component
+Protectedmultiton
The Multiton Key for this app
+Protected StaticMULTITON_
Message Constants
+StaticNAME
The default name for the mediator.
+ Accessors
facade
name
- get name(): string
the mediator name
+Returns string
The name of the mediator.
+
view
- get viewComponent(): any
Get the
+Mediator's view component.Additionally, an implicit getter will usually +be defined in the subclass that casts the view +object to a type, like this:
+Returns any
The view component.
+- set viewComponent(value): void
Set the
+Mediator's view component.Parameters
- value: any
The new view component.
+
Returns void
- value: any
Methods
handle
- handle
Notification(notification): void Handle
+Notifications.Typically, this will be handled in a switch statement, +with one 'case' entry per
+Notification+theMediatoris interested in.Parameters
- notification: INotification
The notification to handle.
+
Returns void
- notification: INotification
initialize
- initialize
Notifier(key): void Initialize this Notifier instance.
+This is how a Notifier gets its multitonKey. +Calls to sendNotification or to access the +facade will fail until after this method +has been called.
+Mediators, Commands or Proxies may override +this method in order to send notifications +or access the Multiton Facade instance as +soon as possible. They CANNOT access the facade +in their constructors, since this method will not +yet have been called.
+Parameters
- key: string
the multitonKey for this Notifier to use
+
Returns void
- key: string
list
on
on
send
- send
Notification(notificationName, body?, type?): void Create and send an
+Notification.Keeps us from having to construct new Notification +instances in our implementation code.
+Parameters
- notificationName: string
The name of the notification to be sent.
+ Optionalbody: anyOptional data to be included with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Class Model
A Multiton Model implementation.
In PureMVC, the Model class provides
+access to model objects (Proxies) by named lookup.
The Model assumes these responsibilities:
-
+
- Maintain a cache of
Proxyinstances.
+ - Provide methods for registering, retrieving, and removing
+
Proxyinstances.
+
Your application must register Proxy instances
+with the Model. Typically, you use an
+Command to create and register Proxy
+instances once the Facade has initialized the Core
+actors.
Implements
Index
Constructors
Properties
Methods
Properties
Protectedmultiton
The Multiton Key for this Core
+Protectedproxy
Mapping of proxyNames to IProxy instances
+Protected StaticMULTITON_
Message Constants
+Protected Staticinstance
Multiton Instances
+ Methods
has
Protectedinitialize
register
- register
Proxy(proxy): void Register a
+Proxywith theModel.Parameters
- proxy: IProxy
The proxy instance to be registered.
+
Returns void
- proxy: IProxy
remove
retrieve
Staticget
Staticremove
Class Notification
A base Notification implementation.
PureMVC does not rely upon underlying event models such +as the one provided with Flash, and ActionScript 3 does +not have an inherent event model.
+The Observer Pattern as implemented within PureMVC exists +to support event-driven communication between the +application and the actors of the MVC triad.
+Notifications are not meant to be a replacement for Events
+in Flex/Flash/Apollo. Generally, Mediator implementors
+place event listeners on their view components, which they
+then handle in the usual way. This may lead to the broadcast of Notifications to
+trigger Commands or to communicate with other Mediators. Proxy and Command
+instances communicate with each other and Mediators
+by broadcasting Notifications.
A key difference between Flash Events and PureMVC
+Notifications is that Events follow the
+'Chain of Responsibility' pattern, 'bubbling' up the display hierarchy
+until some parent component handles the Event, while
+PureMVC Notifications follow a 'Publish/Subscribe'
+pattern. PureMVC classes need not be related to each other in a
+parent/child relationship in order to communicate with one another
+using Notifications.
Notification
+Implements
Index
Constructors
constructor
- new
Notification(name, body?, type?): Notification Constructor.
+Parameters
- name: string
The name of the notification.
+ Optionalbody: anyOptional data to be included with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns Notification
- name: string
Accessors
body
- get body(): any
Get the body of the
+Notificationinstance.Returns any
The body of the notification.
+- set body(value): void
Set the body of the
+Notificationinstance.Parameters
- value: any
The new body to be set for the notification.
+
Returns void
- value: any
name
- get name(): string
Get the name of the
+Notificationinstance.Returns string
The name of the notification.
+
type
- get type(): undefined | string
Get the type of the
+Notificationinstance.Returns undefined | string
The type of the notification, or
+undefinedif not set.- set type(value): void
Set the type of the
+Notificationinstance.Parameters
- value: undefined | string
The new type to be set for the notification.
+
Returns void
- value: undefined | string
Class Notifier
A Base Notifier implementation.
MacroCommand, Command, Mediator and Proxy
+all have a need to send Notifications.
The Notifier interface provides a common method called
+sendNotification that relieves implementation code of
+the necessity to actually construct Notifications.
The Notifier class, which all the above-mentioned classes
+extend, provides an initialized reference to the Facade
+Multiton, which is required for the convenience method
+for sending Notifications, but also eases implementation as these
+classes have frequent Facade interactions and usually require
+access to the facade anyway.
NOTE: In the MultiCore version of the framework, there is one caveat to +notifiers, they cannot send notifications or reach the facade until they +have a valid multitonKey.
+The multitonKey is set:
+-
+
- on a Command when it is executed by the Controller +
- on a Mediator is registered with the View +
- on a Proxy is registered with the Model. +
Hierarchy (view full)
- Notifier
Implements
Index
Properties
Protectedmultiton
The Multiton Key for this app
+Protected StaticMULTITON_
Message Constants
+ Methods
initialize
- initialize
Notifier(key): void Initialize this Notifier instance.
+This is how a Notifier gets its multitonKey. +Calls to sendNotification or to access the +facade will fail until after this method +has been called.
+Mediators, Commands or Proxies may override +this method in order to send notifications +or access the Multiton Facade instance as +soon as possible. They CANNOT access the facade +in their constructors, since this method will not +yet have been called.
+Parameters
- key: string
the multitonKey for this Notifier to use
+
Returns void
- key: string
send
- send
Notification(notificationName, body?, type?): void Create and send an
+Notification.Keeps us from having to construct new Notification +instances in our implementation code.
+Parameters
- notificationName: string
The name of the notification to be sent.
+ Optionalbody: anyOptional data to be included with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Class Observer
A base Observer implementation.
An Observer is an object that encapsulates information
+about an interested object with a method that should
+be called when a particular Notification is broadcast.
In PureMVC, the Observer class assumes these responsibilities:
-
+
- Encapsulate the notification (callback) method of the interested object. +
- Encapsulate the notification context (this) of the interested object. +
- Provide methods for setting the notification method and context. +
- Provide a method for notifying the interested object. +
Observer
+Implements
Index
Constructors
Accessors
Methods
Constructors
constructor
- new
Observer(notify?, context?): Observer Constructor.
+The notification method on the interested object should take +one parameter of type
+NotificationParameters
Optionalnotify: null | ((notification: INotification) => void)The method to be called when a notification is received. Can be
+null.Optionalcontext: anyThe context in which to call the
+notifyMethod. Can benull.
Returns Observer
Accessors
notify
- get notifyContext(): any
Get the notifyContext
+Returns any
The current context or
+nullif no context is set.- set notifyContext(value): void
Set the notification context.
+Parameters
- value: any
The context to set. Can be
+null.
Returns void
- value: any
notify
- get notifyMethod(): undefined | null | ((notification: INotification) => void)
Get the notification method.
+Returns undefined | null | ((notification: INotification) => void)
The current method or
+nullif no method is set.- set notifyMethod(value): void
Set the notification method.
+The notification method should take one parameter of type
+Notification.Parameters
- value: null | ((notification: INotification) => void)
The method to set for handling notifications. Can be
+null.
Returns void
- value: null | ((notification: INotification) => void)
Methods
compare
notify
- notify
Observer(notification): void Notify the interested object.
+Parameters
- notification: INotification
The notification to send to the observer.
+
Returns void
- notification: INotification
Class Proxy
A base Proxy implementation.
In PureMVC, Proxy classes are used to manage parts of the
+application's data model.
A Proxy might simply manage a reference to a local data object,
+in which case interacting with it might involve setting and
+getting of its data in synchronous fashion.
Proxy classes are also used to encapsulate the application's
+interaction with remote services to save or retrieve data, in which case,
+we adopt an asynchronous idiom; setting data (or calling a method) on the
+Proxy and listening for a Notification to be sent
+when the Proxy has retrieved the data from the service.
Hierarchy (view full)
- Notifier
- Proxy
Implements
Index
Constructors
Properties
Accessors
Methods
Properties
Protected Optional_data
the data object
+Protected Readonly_name
the proxy name
+Protectedmultiton
The Multiton Key for this app
+Protected StaticMULTITON_
Message Constants
+StaticNAME
The default name for the Proxy.
+ Accessors
data
- get data(): any
Get the data object
+Returns any
The current data or
+undefinedif no data is set.- set data(value): void
Set the data object
+Parameters
- value: any
The data to set. Can be
+null.
Returns void
- value: any
facade
name
- get name(): string
Get the proxy name
+Returns string
The name of the proxy.
+
Methods
initialize
- initialize
Notifier(key): void Initialize this Notifier instance.
+This is how a Notifier gets its multitonKey. +Calls to sendNotification or to access the +facade will fail until after this method +has been called.
+Mediators, Commands or Proxies may override +this method in order to send notifications +or access the Multiton Facade instance as +soon as possible. They CANNOT access the facade +in their constructors, since this method will not +yet have been called.
+Parameters
- key: string
the multitonKey for this Notifier to use
+
Returns void
- key: string
on
on
send
- send
Notification(notificationName, body?, type?): void Create and send an
+Notification.Keeps us from having to construct new Notification +instances in our implementation code.
+Parameters
- notificationName: string
The name of the notification to be sent.
+ Optionalbody: anyOptional data to be included with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Class SimpleCommand
A base Command implementation.
Your subclass should override the execute
+method where your business logic will handle the Notification.
Hierarchy (view full)
- Notifier
- SimpleCommand
Implements
Index
Constructors
constructor
- new
Simple Command(): SimpleCommand Returns SimpleCommand
Properties
Protectedmultiton
The Multiton Key for this app
+Protected StaticMULTITON_
Message Constants
+ Methods
execute
- execute(notification): void
Fulfill the use-case initiated by the given
+Notification.In the Command Pattern, an application use-case typically +begins with some user action, which results in a
+Notificationbeing broadcast, which +is handled by business logic in theexecutemethod of an +Command.Parameters
- notification: INotification
The notification containing the data or command details to be processed.
+
Returns void
- notification: INotification
initialize
- initialize
Notifier(key): void Initialize this Notifier instance.
+This is how a Notifier gets its multitonKey. +Calls to sendNotification or to access the +facade will fail until after this method +has been called.
+Mediators, Commands or Proxies may override +this method in order to send notifications +or access the Multiton Facade instance as +soon as possible. They CANNOT access the facade +in their constructors, since this method will not +yet have been called.
+Parameters
- key: string
the multitonKey for this Notifier to use
+
Returns void
- key: string
send
- send
Notification(notificationName, body?, type?): void Create and send an
+Notification.Keeps us from having to construct new Notification +instances in our implementation code.
+Parameters
- notificationName: string
The name of the notification to be sent.
+ Optionalbody: anyOptional data to be included with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Class View
A Multiton View implementation.
In PureMVC, the View class assumes these responsibilities:
-
+
- Maintain a cache of
Mediatorinstances.
+ - Provide methods for registering, retrieving, and removing
Mediators.
+ - Notifying
Mediatorswhen they are registered or removed.
+ - Managing the observer lists for each
Notificationin the application.
+ - Providing a method for attaching
Observersto aNotification's observer list.
+ - Providing a method for broadcasting a
Notification.
+ - Notifying the
Observersof a givenNotificationwhen it broadcast.
+
Implements
Index
Constructors
Properties
Methods
Properties
Protectedmediator
Mapping of Mediator names to Mediator instances
+Protectedmultiton
The Multiton Key for this Core
+Protectedobserver
Mapping of Notification names to Observer lists
+Protected StaticMULTITON_
Message Constants
+Protected Staticinstance
Multiton Instances
+ Methods
has
notify
- notify
Observers(notification): void Notify the
+Observersfor a particularNotification.All previously attached
+Observersfor thisNotification's +list are notified and are passed a reference to theNotificationin +the order in which they were registered.Parameters
- notification: INotification
The notification containing the data or command details to be sent to observers.
+
Returns void
- notification: INotification
register
- register
Mediator(mediator): void Register a
+Mediatorinstance with theView.Registers the
+Mediatorso that it can be retrieved by name, +and further interrogates theMediatorfor its +Notificationinterests.If the
+Mediatorreturns anyNotification+names to be notified about, anObserveris created encapsulating +theMediatorinstance'shandleNotificationmethod +and registering it as anObserverfor allNotificationsthe +Mediatoris interested in.Parameters
- mediator: IMediator
The mediator instance to be registered.
+
Returns void
- mediator: IMediator
register
- register
Observer(notificationName, observer): void Register an
+Observerto be notified +ofNotificationswith a given name.Parameters
- notificationName: string
The name of the notification to which the observer should be registered.
+ - observer: IObserver
The observer instance to be registered.
+
Returns void
- notificationName: string
remove
remove
- remove
Observer(notificationName, notifyContext): void Remove the observer for a given notifyContext from an observer list for a given Notification name.
+Parameters
- notificationName: string
The name of the notification for which the observer should be removed.
+ - notifyContext: any
The context of the observer to be removed.
+
Returns void
- notificationName: string
retrieve
Staticget
Staticremove
@puremvc/puremvc-typescript-multicore-framework
Class Hierarchy
@puremvc/puremvc-typescript-multicore-framework
PureMVC TypeScript MultiCore Framework 
PureMVC is a lightweight framework for creating applications based upon the classic Model-View-Controller design meta-pattern. It supports modular programming through the use of Multiton Core actors instead of the Singletons.
+ +Installation
npm install @puremvc/puremvc-typescript-multicore-framework
+Demos
+Platforms / Technologies
-
+
- JavaScript +
- ECMAScript +
- CommonJS +
- Node.js +
- React +
- React Native +
Status
Production - Version 2.0.0
+License
-
+
-
+
PureMVC MultiCore Framework for TypeScript - Copyright © 2024 Saad Shams
+
+ -
+
PureMVC - Copyright © 2024 Futurescale, Inc.
+
+ -
+
All rights reserved.
+
+ -
+
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+-
+
- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +
- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +
- Neither the name of Futurescale, Inc., PureMVC.org, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. +
+
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Interface ICommand
The interface definition for a PureMVC Command.
+execute(notification: INotification): void;
initializeNotifier(key: string): void;
sendNotification(notificationName: string, body?: any, type?: string): void;
}
Hierarchy (view full)
- INotifier
- ICommand
Implemented by
Index
Methods
Methods
execute
- execute(notification): void
Execute the
+ICommand's logic to handle a givenINotification.Parameters
- notification: INotification
The notification carrying the data and type necessary for executing the command.
+
Returns void
- notification: INotification
initialize
send
- send
Notification(notificationName, body?, type?): void Send a
+INotification.Convenience method to prevent having to construct new +notification instances in our implementation code.
+Parameters
- notificationName: string
The name of the notification to send.
+ Optionalbody: anyOptional data associated with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Interface IController
IController The interface definition for a PureMVC Controller.
In PureMVC, an IController implementor
+follows the 'Command and Controller' strategy, and
+assumes these responsibilities:
-
+
-
+
Remembering which
+ICommandsare intended to handle whichINotifications.
+ -
+
Registering itself as an
+IObserverwith the View for eachINotificationthat it has anICommandmapping for.
+ -
+
Creating a new instance of the proper
+ICommandto handle a givenINotificationwhen notified by theView.
+ -
+
Calling the
+ICommand's execute method, passing in theINotification.
+
IController
+executeCommand(notification: INotification): void;
hasCommand(notificationName: string): boolean;
registerCommand(notificationName: string, factory: (() => ICommand)): void;
removeCommand(notificationName: string): void;
}
Implemented by
Index
Methods
Methods
execute
- execute
Command(notification): void Execute the
+ICommandpreviously registered as the +handler forINotificationswith the given notification name.Parameters
- notification: INotification
the
+INotificationto execute the associatedICommandfor
Returns void
- notification: INotification
has
register
remove
Interface IFacade
IFacade The interface definition for a PureMVC Facade.
The Facade Pattern suggests providing a single
+class to act as a central point of communication
+for a subsystem.
In PureMVC, the Facade acts as an interface between
+the core MVC actors (Model, View, Controller) and
+the rest of your application.
IFacade
+hasCommand(notificationName: string): boolean;
hasMediator(mediatorName: string): boolean;
hasProxy(proxyName: string): boolean;
initializeNotifier(key: string): void;
notifyObservers(notification: INotification): void;
registerCommand(notificationName: string, factory: (() => ICommand)): void;
registerMediator(mediator: IMediator): void;
registerProxy(proxy: IProxy): void;
removeCommand(notificationName: string): void;
removeMediator(mediatorName: string): null | IMediator;
removeProxy(proxyName: string): null | IProxy;
retrieveMediator(mediatorName: string): null | IMediator;
retrieveProxy(proxyName: string): null | IProxy;
sendNotification(notificationName: string, body?: any, type?: string): void;
}
Hierarchy (view full)
- INotifier
- IFacade
Implemented by
Methods
has
has
has
initialize
- initialize
Notifier(key): void Set the Multiton key for this facade instance.
+Not called directly, but instead from the +constructor when
+getInstanceis invoked. +It is necessary to be public in order to +implement Notifier.Parameters
- key: string
The unique key to initialize the notifier with.
+
Returns void
- key: string
notify
- notify
Observers(notification): void Notify Observers.
+This method is left public mostly for backward +compatibility, and to allow you to send custom +notification classes using the facade.
+Usually you should just call
+sendNotification+and pass the parameters, never having to +construct the notification yourself.Parameters
- notification: INotification
the
+INotificationto have theViewnotifyObserversof.
Returns void
- notification: INotification
register
register
- register
Mediator(mediator): void Register an
+IMediatorinstance with theView.Parameters
- mediator: IMediator
a reference to the
+IMediatorinstance
Returns void
- mediator: IMediator
register
- register
Proxy(proxy): void Register an
+IProxywith theModelby name.Parameters
- proxy: IProxy
the IProxy to be registered with the Model.
+
Returns void
- proxy: IProxy
remove
remove
remove
retrieve
retrieve
send
- send
Notification(notificationName, body?, type?): void Create and send an
+Notification.Keeps us from having to construct new notification +instances in our implementation code.
+Parameters
- notificationName: string
the
+INotificationto have theViewnotifyObserversof. Optionalbody: anyOptional data to be included in the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Interface IMediator
IMediator The interface definition for a PureMVC Mediator.
In PureMVC, IMediator implementors assume these responsibilities:
-
+
-
+
Implement a common method which returns a list of all
+INotificationstheIMediatorhas interest in.
+ -
+
Implement a notification callback method.
+
+ -
+
Implement methods that are called when the
+IMediatoris registered or removed from the View.
+
Additionally, IMediators typically:
-
+
-
+
Act as an intermediary between one or more view components such as text boxes or list controls, maintaining references and coordinating their behavior.
+
+ -
+
In Flash-based apps, this is often the place where event listeners are added to view components, and their handlers implemented.
+
+ -
+
Respond to and generate
+INotifications, interacting with of the rest of the PureMVC app.
+
When an IMediator is registered with the IView,
+the IView will call the IMediator's
+listNotificationInterests method. The IMediator will
+return an Array of INotification names which
+it wishes to be notified about.
The IView will then create an Observer object
+encapsulating that IMediator's (handleNotification) method
+and register it as an Observer for each INotification name returned by
+listNotificationInterests.
IMediator
+name: string;
viewComponent: any;
handleNotification(notification: INotification): void;
initializeNotifier(key: string): void;
listNotificationInterests(): string[];
onRegister(): void;
onRemove(): void;
sendNotification(notificationName: string, body?: any, type?: string): void;
}
Hierarchy (view full)
- INotifier
- IMediator
Implemented by
Index
Properties
Methods
Properties
Readonlyname
The name of the mediator.
+view
The view component associated with the mediator.
+ Methods
handle
- handle
Notification(notification): void Handle an
+INotification.Parameters
- notification: INotification
the
+INotificationto be handled
Returns void
- notification: INotification
initialize
list
on
on
send
- send
Notification(notificationName, body?, type?): void Send a
+INotification.Convenience method to prevent having to construct new +notification instances in our implementation code.
+Parameters
- notificationName: string
The name of the notification to send.
+ Optionalbody: anyOptional data associated with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Interface IModel
IModel The interface definition for a PureMVC Model.
In PureMVC, IModel implementors provide
+access to IProxy objects by named lookup.
An IModel assumes these responsibilities:
-
+
-
+
Maintain a cache of
+IProxyinstances
+ -
+
Provide methods for registering, retrieving, and removing
+IProxyinstances
+
IModel
+hasProxy(proxyName: string): boolean;
registerProxy(proxy: IProxy): void;
removeProxy(proxyName: string): null | IProxy;
retrieveProxy(proxyName: string): null | IProxy;
}
Implemented by
Index
Methods
Methods
has
register
- register
Proxy(proxy): void Register an
+IProxyinstance with theModel.Parameters
- proxy: IProxy
an object reference to be held by the
+Model.
Returns void
- proxy: IProxy
remove
retrieve
Interface INotification
INotification The interface definition for a PureMVC Notification.
PureMVC does not rely upon underlying event models such +as the one provided with Flash, and ActionScript 3 does +not have an inherent event model.
+The Observer Pattern as implemented within PureMVC exists
+to support event-driven communication between the
+application and the actors of the MVC triad.
Notifications are not meant to be a replacement for Events
+in Flex/Flash/AIR. Generally, IMediator implementors
+place event listeners on their view components, which they
+then handle in the usual way. This may lead to the broadcast of Notifications to
+trigger ICommands or to communicate with other IMediators. IProxy and ICommand
+instances communicate with each other and IMediators
+by broadcasting INotifications.
A key difference between Flash Events and PureMVC
+Notifications is that Events follow the
+'Chain of Responsibility' pattern, 'bubbling' up the display hierarchy
+until some parent component handles the Event, while
+PureMVC Notifications follow a 'Publish/Subscribe'
+pattern. PureMVC classes need not be related to each other in a
+parent/child relationship in order to communicate with one another
+using Notifications.
INotification
+Implemented by
Interface INotifier
INotifier The interface definition for a PureMVC Notifier.
MacroCommand, Command, Mediator and Proxy
+all have a need to send Notifications.
The INotifier interface provides a common method called
+sendNotification that relieves implementation code of
+the necessity to actually construct Notifications.
The Notifier class, which all the above-mentioned classes
+extend, also provides an initialized reference to the Facade
+Multiton, which is required for the convenience method
+for sending Notifications, but also eases implementation as these
+classes have frequent Facade interactions and usually require
+access to the facade anyway.
INotifier
+initializeNotifier(key: string): void;
sendNotification(notificationName: string, body?: any, type?: string): void;
}
Hierarchy (view full)
Implemented by
Index
Methods
Methods
initialize
send
- send
Notification(notificationName, body?, type?): void Send a
+INotification.Convenience method to prevent having to construct new +notification instances in our implementation code.
+Parameters
- notificationName: string
The name of the notification to send.
+ Optionalbody: anyOptional data associated with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Interface IObserver
IObserver The interface definition for a PureMVC Observer.
In PureMVC, IObserver implementors assume these responsibilities:
-
+
-
+
Encapsulate the notification (callback) method of the interested object.
+
+ -
+
Encapsulate the notification context (self) of the interested object.
+
+ -
+
Provide methods for setting the interested object notification method and context.
+
+ -
+
Provide a method for notifying the interested object.
+
+
PureMVC does not rely upon underlying event +models such as the one provided with Flash, +and ActionScript 3 does not have an inherent +event model.
+The Observer Pattern as implemented within
+PureMVC exists to support event driven communication
+between the application and the actors of the
+MVC triad.
An Observer is an object that encapsulates information
+about an interested object with a notification method that
+should be called when an INotification is broadcast.
+The Observer then acts as a proxy for notifying the interested object.
Observers can receive Notifications by having their
+notifyObserver method invoked, passing
+in an object implementing the INotification interface, such
+as a subclass of Notification.
IObserver
+notifyContext?: any;
notifyMethod?: null | ((notification: INotification) => void);
compareNotifyContext(object: any): boolean;
notifyObserver(notification: INotification): void;
}
Implemented by
Index
Properties
Methods
Properties
Optionalnotify
The context in which the notification method should be called.
+Optionalnotify
The method to be called when a notification is received.
+ Methods
compare
notify
- notify
Observer(notification): void Notify the interested object.
+Parameters
- notification: INotification
the
+INotificationto pass to the interested object's notification method
Returns void
- notification: INotification
Interface IProxy
IProxy The interface definition for a PureMVC Proxy.
In PureMVC, IProxy implementors assume these responsibilities:
-
+
-
+
Implement a common method which returns the name of the Proxy.
+
+ -
+
Provide methods for setting and getting the data object.
+
+
Additionally, IProxyies typically:
-
+
-
+
Maintain references to one or more pieces of model data.
+
+ -
+
Provide methods for manipulating that data.
+
+ -
+
Generate
+INotificationswhen their model data changes.
+ -
+
Expose their name as a public static const called
+NAME, if they are not instantiated multiple times.
+ -
+
Encapsulate interaction with local or remote services used to fetch and persist model data.
+
+
IProxy
+data?: any;
name: string;
initializeNotifier(key: string): void;
onRegister(): void;
onRemove(): void;
sendNotification(notificationName: string, body?: any, type?: string): void;
}
Hierarchy (view full)
- INotifier
- IProxy
Implemented by
Index
Properties
Methods
Properties
Optionaldata
The data associated with the proxy.
+Readonlyname
The name of the proxy.
+ Methods
initialize
on
on
send
- send
Notification(notificationName, body?, type?): void Send a
+INotification.Convenience method to prevent having to construct new +notification instances in our implementation code.
+Parameters
- notificationName: string
The name of the notification to send.
+ Optionalbody: anyOptional data associated with the notification.
+Optionaltype: stringOptional type of the notification.
+
Returns void
- notificationName: string
Interface IView
IView The interface definition for a PureMVC View.
In PureMVC, the View class assumes these responsibilities:
+-
+
-
+
Maintain a cache of
+IMediatorinstances.
+ -
+
Provide methods for registering, retrieving, and removing
+IMediators.
+ -
+
Managing the observer lists for each
+INotificationin the application.
+ -
+
Providing a method for attaching
+IObserversto anINotification's observer list.
+ -
+
Providing a method for broadcasting an
+INotification.
+ -
+
Notifying the
+IObserversof a givenINotificationwhen it is broadcast.
+
IView
+hasMediator(mediatorName: string): boolean;
notifyObservers(notification: INotification): void;
registerMediator(mediator: IMediator): void;
registerObserver(notificationName: string, observer: IObserver): void;
removeMediator(mediatorName: string): null | IMediator;
removeObserver(notificationName: string, notifyContext: any): void;
retrieveMediator(mediatorName: string): null | IMediator;
}
Implemented by
Index
Methods
has
notify
- notify
Observers(notification): void Notify the
+IObserversfor a particularINotification.All previously attached
+IObserversfor thisINotification's +list are notified and are passed a reference to theINotificationin +the order in which they were registered.Parameters
- notification: INotification
the
+INotificationto notifyIObserversof.
Returns void
- notification: INotification
register
- register
Mediator(mediator): void Register an
+IMediatorinstance with the View.Registers the
+IMediatorso that it can be retrieved by name, +and further interrogates theIMediatorfor its +INotificationinterests.If the
+IMediatorreturns anyINotification+names to be notified about, anObserveris created encapsulating +theIMediatorinstance'shandleNotificationmethod +and registering it as anObserverfor allINotificationsthe +IMediatoris interested in.Parameters
- mediator: IMediator
The
+IMediatorto be registered.
Returns void
- mediator: IMediator
register
- register
Observer(notificationName, observer): void Register an
+IObserverto be notified +ofINotificationswith a given name.Parameters
- notificationName: string
The name of the notification to register the observer for.
+ - observer: IObserver
The observer to be registered.
+
Returns void
- notificationName: string
A Multiton
+Controllerimplementation.In PureMVC, the
+Controllerclass follows the +'Command and Controller' strategy, and assumes these +responsibilities:+- Remembering which
+- Registering itself as an
+- Creating a new instance of the proper
+- Calling the
+
+Commands +are intended to handle whichNotifications.Observerwith +theViewfor eachNotification+that it has aCommandmapping for.Command+to handle a givenNotificationwhen notified by theView.Command'sexecute+method, passing in theNotification.Your application must register
+Commandswith the +Controller.The simplest way is to subclass
+Facade, +and use itsinitializeControllermethod to add your +registrations.See
+- View
+- Observer
+- Notification
+- SimpleCommand
+- MacroCommand
+
+Controller
+