2166 строки
71 KiB
TypeScript
2166 строки
71 KiB
TypeScript
/*!
|
|
* Labs.js JavaScript API for Office Mix
|
|
* Version: 1.0.4 * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Your use of this file is governed by the Microsoft Services Agreement http://go.microsoft.com/fwlink/?LinkId=266419.
|
|
*/
|
|
declare module Labs.Core {
|
|
/**
|
|
* Definition of a lab action. An action represents an interaction a user has taken with the lab.
|
|
*/
|
|
interface IAction {
|
|
/**
|
|
* The type of action taken.
|
|
*/
|
|
type: string;
|
|
/**
|
|
* The options sent with the action
|
|
*/
|
|
options: Core.IActionOptions;
|
|
/**
|
|
* The result of the action
|
|
*/
|
|
result: Core.IActionResult;
|
|
/**
|
|
* The time at which the action was completed. In milliseconds elapsed since 1 January 1970 00:00:00 UTC.
|
|
*/
|
|
time: number;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* The results of taking an action. Depending on the type of action these will either be set by the server side
|
|
* or provided by the client when taking the action.
|
|
*/
|
|
interface IActionResult {
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Base class for instances of a lab component. An instance is an instantiation of a component for a user. It contains
|
|
* a translated view of the component for a particular run of the lab. This view may exclude hidden information (answers, hints, etc...)
|
|
* and also contains IDs to identify the various instances.
|
|
*/
|
|
interface IComponentInstance extends Core.ILabObject, Core.IUserData {
|
|
/**
|
|
* The ID of the component this instance is associated with
|
|
*/
|
|
componentId: string;
|
|
/**
|
|
* The name of the component
|
|
*/
|
|
name: string;
|
|
/**
|
|
* value property map associated with the component
|
|
*/
|
|
values: {
|
|
[type: string]: Core.IValueInstance[];
|
|
};
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Information about the lab configuration.
|
|
*/
|
|
interface IConfigurationInfo {
|
|
/**
|
|
* The version of the host the lab configuration was created with.
|
|
*/
|
|
hostVersion: Core.IVersion;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Response information coming from a connection call
|
|
*/
|
|
interface IConnectionResponse {
|
|
/**
|
|
* Initialization information or null if the app has not yet been initialized
|
|
*/
|
|
initializationInfo: Core.IConfigurationInfo;
|
|
/**
|
|
* The current mode the lab is running in
|
|
*/
|
|
mode: Core.LabMode;
|
|
/**
|
|
* Version information for server side
|
|
*/
|
|
hostVersion: Core.IVersion;
|
|
/**
|
|
* Information about the user
|
|
*/
|
|
userInfo: Core.IUserInfo;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Options passed as part of a get action
|
|
*/
|
|
interface IGetActionOptions {
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Options passed as part of a lab create.
|
|
*/
|
|
interface ILabCreationOptions {
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Version information about the lab host
|
|
*/
|
|
interface ILabHostVersionInfo {
|
|
/**
|
|
* The API version of the host
|
|
*/
|
|
version: Core.IVersion;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Definition of lab action options. These are the options passed when performing a given action.
|
|
*/
|
|
interface IActionOptions {
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Base interface for messages sent between the client and the host.
|
|
*/
|
|
interface IMessage {
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Base interface for responses to messages sent to the host.
|
|
*/
|
|
interface IMessageResponse {
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* User information
|
|
*/
|
|
interface IUserInfo {
|
|
/**
|
|
* Unique identifier for the given lab user
|
|
*/
|
|
id: string;
|
|
/**
|
|
* Permissions the user has access to
|
|
*/
|
|
permissions: string[];
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* An intance of an IValue
|
|
*/
|
|
interface IValueInstance {
|
|
/**
|
|
* ID for the value this instance represents
|
|
*/
|
|
valueId: string;
|
|
/**
|
|
* Flag indicating whether or not this value is considered a hint
|
|
*/
|
|
isHint: boolean;
|
|
/**
|
|
* Flag indicating whether or not the instance information contains the value.
|
|
*/
|
|
hasValue: boolean;
|
|
/**
|
|
* The value. May or may not be set depending on if it has been hidden.
|
|
*/
|
|
value?: any;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Version information
|
|
*/
|
|
interface IVersion {
|
|
/**
|
|
* Major version
|
|
*/
|
|
major: number;
|
|
/**
|
|
* Minor version
|
|
*/
|
|
minor: number;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Custom analytics configuration information. Allows the develper to specify which iframe to load
|
|
* in order to display custom analytics for a user's run of a lab.
|
|
*/
|
|
interface IAnalyticsConfiguration {
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Completion status for the lab. Passed when completing the lab to indicate the result of the interaction.
|
|
*/
|
|
interface ICompletionStatus {
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Interface for Labs.js callback methods
|
|
*/
|
|
interface ILabCallback<T> {
|
|
/**
|
|
* Callback signature
|
|
*
|
|
* @param { err } If an error has occurred this will be non-null
|
|
* @param { data } The data returned with the callback
|
|
*/
|
|
(err: any, data: T): void;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* A lab object contains a type field which indicates what type of object it is
|
|
*/
|
|
interface ILabObject {
|
|
/**
|
|
* The type name for the object
|
|
*/
|
|
type: string;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Timeline configuration options. Allows the lab developer to specify a set of timeline configuration options.
|
|
*/
|
|
interface ITimelineConfiguration {
|
|
/**
|
|
* The duration of the lab in seconds
|
|
*/
|
|
duration: number;
|
|
/**
|
|
* A list of timeline capabilities the lab supports. i.e. play, pause, seek, fast forward...
|
|
*/
|
|
capabilities: string[];
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Base interface to represent custom user data stored on an object
|
|
*/
|
|
interface IUserData {
|
|
/**
|
|
* An optional data field stored on the object for custom fields.
|
|
*/
|
|
data?: any;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Base class for values stored with a lab
|
|
*/
|
|
interface IValue {
|
|
/**
|
|
* Flag indicating whether or not this value is considered a hint
|
|
*/
|
|
isHint: boolean;
|
|
/**
|
|
* The value
|
|
*/
|
|
value: any;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Lab configuration data structure
|
|
*/
|
|
interface IConfiguration extends Core.IUserData {
|
|
/**
|
|
* The version of the application associated with this configuration
|
|
*/
|
|
appVersion: Core.IVersion;
|
|
/**
|
|
* The components of the lab
|
|
*/
|
|
components: Core.IComponent[];
|
|
/**
|
|
* The name of the lab
|
|
*/
|
|
name: string;
|
|
/**
|
|
* Lab timeline configuration
|
|
*/
|
|
timeline: Core.ITimelineConfiguration;
|
|
/**
|
|
* Lab analytics configuration
|
|
*/
|
|
analytics: Core.IAnalyticsConfiguration;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Base class for instances of a lab configuration. An instance is an instantiation of a configuration for a user. It contains
|
|
* a translated view of the configuration for a particular run of the lab. This view may exclude hidden information (answers, hints, etc...)
|
|
* and also contains IDs to identify the various instances.
|
|
*/
|
|
interface IConfigurationInstance extends Core.IUserData {
|
|
/**
|
|
* The version of the application associated with this configuration
|
|
*/
|
|
appVersion: Core.IVersion;
|
|
/**
|
|
* The components of the lab
|
|
*/
|
|
components: Core.IComponentInstance[];
|
|
/**
|
|
* The name of the lab
|
|
*/
|
|
name: string;
|
|
/**
|
|
* Lab timeline configuration
|
|
*/
|
|
timeline: Core.ITimelineConfiguration;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Base class for components of a lab.
|
|
*/
|
|
interface IComponent extends Core.ILabObject, Core.IUserData {
|
|
/**
|
|
* The name of the component
|
|
*/
|
|
name: string;
|
|
/**
|
|
* value property map associated with the component
|
|
*/
|
|
values: {
|
|
[type: string]: Core.IValue[];
|
|
};
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* The current mode of the lab. Whether in edit mode or view mode. Edit is when configuring the lab and view
|
|
* is when taking the lab.
|
|
*/
|
|
enum LabMode {
|
|
/**
|
|
* The lab is in edit mode. Meaning the user is configuring it
|
|
*/
|
|
Edit,
|
|
/**
|
|
* The lab is in view mode. Meaning the user is taking it
|
|
*/
|
|
View,
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* The ILabHost interfaces provides an abstraction for connecting Labs.js to the host
|
|
*/
|
|
interface ILabHost {
|
|
/**
|
|
* Retrieves the versions supported by this lab host.
|
|
*/
|
|
getSupportedVersions(): Core.ILabHostVersionInfo[];
|
|
/**
|
|
* Initializes communication with the host
|
|
*
|
|
* @param { versions } The list of versions that the client of the host can make use of
|
|
* @param { callback } Callback for when the connection is complete
|
|
*/
|
|
connect(versions: Core.ILabHostVersionInfo[], callback: Core.ILabCallback<Core.IConnectionResponse>);
|
|
/**
|
|
* Stops communication with the host
|
|
*
|
|
* @param { completionStatus } The final status of the lab at the time of the disconnect
|
|
* @param { callback } Callback fired when the disconnect completes
|
|
*/
|
|
disconnect(callback: Core.ILabCallback<void>);
|
|
/**
|
|
* Adds an event handler for dealing with messages coming from the host. The resolved promsie
|
|
* will be returned back to the host
|
|
*
|
|
* @param { handler } The event handler
|
|
*/
|
|
on(handler: (string: any, any: any) => void);
|
|
/**
|
|
* Sends a message to the host
|
|
*
|
|
* @param { type } The type of message being sent
|
|
* @param { options } The options for that message
|
|
* @param { callback } Callback invoked once the message has been received
|
|
*/
|
|
sendMessage(type: string, options: Core.IMessage, callback: Core.ILabCallback<Core.IMessageResponse>);
|
|
/**
|
|
* Creates the lab. Stores the host information and sets aside space for storing the configuration and other elements.
|
|
*
|
|
* @param { options } Options passed as part of creation
|
|
*/
|
|
create(options: Core.ILabCreationOptions, callback: Core.ILabCallback<void>);
|
|
/**
|
|
* Gets the current lab configuration from the host
|
|
*
|
|
* @param { callback } Callback method for retrieving configuration information
|
|
*/
|
|
getConfiguration(callback: Core.ILabCallback<Core.IConfiguration>);
|
|
/**
|
|
* Sets a new lab configuration on the host
|
|
*
|
|
* @param { configuration } The lab configuration to set
|
|
* @param { callback } Callback fired when the configuration is set
|
|
*/
|
|
setConfiguration(configuration: Core.IConfiguration, callback: Core.ILabCallback<void>);
|
|
/**
|
|
* Retrieves the instance configuration for the lab
|
|
*
|
|
* @param { callback } Callback that will be called when the configuration instance is retrieved
|
|
*/
|
|
getConfigurationInstance(callback: Core.ILabCallback<Core.IConfigurationInstance>);
|
|
/**
|
|
* Gets the current state of the lab for the user
|
|
*
|
|
* @param { completionStatus } Callback that will return the current lab state
|
|
*/
|
|
getState(callback: Core.ILabCallback<any>);
|
|
/**
|
|
* Sets the state of the lab for the user
|
|
*
|
|
* @param { state } The lab state
|
|
* @param { callback } Callback that will be invoked when the state has been set
|
|
*/
|
|
setState(state: any, callback: Core.ILabCallback<void>);
|
|
/**
|
|
* Takes an attempt action
|
|
*
|
|
* @param { type } The type of action
|
|
* @param { options } The options provided with the action
|
|
* @param { callback } Callback which returns the final executed action
|
|
*/
|
|
takeAction(type: string, options: Core.IActionOptions, callback: Core.ILabCallback<Core.IAction>);
|
|
/**
|
|
* Takes an action that has already been completed
|
|
*
|
|
* @param { type } The type of action
|
|
* @param { options } The options provided with the action
|
|
* @param { result } The result of the action
|
|
* @param { callback } Callback which returns the final executed action
|
|
*/
|
|
takeAction(type: string, options: Core.IActionOptions, result: Core.IActionResult, callback: Core.ILabCallback<Core.IAction>);
|
|
/**
|
|
* Retrieves the actions for a given attempt
|
|
*
|
|
* @param { type } The type of get action
|
|
* @param { options } The options provided with the get action
|
|
* @param { callback } Callback which returns the list of completed actions
|
|
*/
|
|
getActions(type: string, options: Core.IGetActionOptions, callback: Core.ILabCallback<Core.IAction[]>);
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Static class representing the permissions allowed for the given user of the lab
|
|
*/
|
|
class Permissions {
|
|
/**
|
|
* Ability to edit the lab
|
|
*/
|
|
static Edit: string;
|
|
/**
|
|
* Ability to take the lab
|
|
*/
|
|
static Take: string;
|
|
}
|
|
}
|
|
|
|
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* Closes the component and indicates there will be no future actions against it.
|
|
*/
|
|
var CloseComponentAction: string;
|
|
/**
|
|
* Closes a component and indicates there will be no more actions against it.
|
|
*/
|
|
interface ICloseComponentOptions extends Core.IActionOptions {
|
|
/**
|
|
* The component to close.
|
|
*/
|
|
componentId: string;
|
|
}
|
|
}
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* Action to create a new attempt
|
|
*/
|
|
var CreateAttemptAction: string;
|
|
/**
|
|
* Creates a new attempt for the given component.
|
|
*/
|
|
interface ICreateAttemptOptions extends Core.IActionOptions {
|
|
/**
|
|
* The component the attempt is associated with
|
|
*/
|
|
componentId: string;
|
|
}
|
|
}
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* The result of creating an attempt for the given component.
|
|
*/
|
|
interface ICreateAttemptResult extends Core.IActionResult {
|
|
/**
|
|
* The ID of the created attempt
|
|
*/
|
|
attemptId: string;
|
|
}
|
|
}
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* Action to create a new component
|
|
*/
|
|
var CreateComponentAction: string;
|
|
/**
|
|
* Creates a new component
|
|
*/
|
|
interface ICreateComponentOptions extends Core.IActionOptions {
|
|
/**
|
|
* The component invoking the create component action.
|
|
*/
|
|
componentId: string;
|
|
/**
|
|
* The component to create
|
|
*/
|
|
component: Core.IComponent;
|
|
/**
|
|
* An (optional) field used to correlate this component across all instances of a lab.
|
|
* Allows the hosting system to identify different attempts at the same component.
|
|
*/
|
|
correlationId?: string;
|
|
}
|
|
}
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* The result of creating a new component.
|
|
*/
|
|
interface ICreateComponentResult extends Core.IActionResult {
|
|
/**
|
|
* The created component instance
|
|
*/
|
|
componentInstance: Core.IComponentInstance;
|
|
}
|
|
}
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* The result of a get value action
|
|
*/
|
|
interface IGetValueResult extends Core.IActionResult {
|
|
/**
|
|
* The retrieved value
|
|
*/
|
|
value: any;
|
|
}
|
|
}
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* The result of submitting an answer for an attempt
|
|
*/
|
|
interface ISubmitAnswerResult extends Core.IActionResult {
|
|
/**
|
|
* An ID associated with the submission. Will be filled in by the server.
|
|
*/
|
|
submissionId: string;
|
|
/**
|
|
* Whether the attempt is complete due to this submission
|
|
*/
|
|
complete: boolean;
|
|
/**
|
|
* Scoring information associated with the submission
|
|
*/
|
|
score: any;
|
|
}
|
|
}
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* Attempt timeout action
|
|
*/
|
|
var AttemptTimeoutAction: string;
|
|
/**
|
|
* Options for the attempt timeout action
|
|
*/
|
|
interface IAttemptTimeoutOptions extends Core.IActionOptions {
|
|
/**
|
|
* The ID of the attempt that timed out
|
|
*/
|
|
attemptId: string;
|
|
}
|
|
}
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* Action to retrieve a value associated with an attempt.
|
|
*/
|
|
var GetValueAction: string;
|
|
interface IGetValueOptions extends Core.IActionOptions {
|
|
/**
|
|
* The component the get value is associated with
|
|
*/
|
|
componentId: string;
|
|
/**
|
|
* The attempt to get the value for
|
|
*/
|
|
attemptId: string;
|
|
/**
|
|
* The ID of the value to receive
|
|
*/
|
|
valueId: string;
|
|
}
|
|
}
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* Resume attempt action. Used to indicate the user is resuming work on a given attempt.
|
|
*/
|
|
var ResumeAttemptAction: string;
|
|
/**
|
|
* Options associated with a resume attempt
|
|
*/
|
|
interface IResumeAttemptOptions extends Core.IActionOptions {
|
|
/**
|
|
* The component the attempt is associated with
|
|
*/
|
|
componentId: string;
|
|
/**
|
|
* The attempt that is being resumed
|
|
*/
|
|
attemptId: string;
|
|
}
|
|
}
|
|
declare module Labs.Core.Actions {
|
|
/**
|
|
* Action to submit an answer for a given attempt
|
|
*/
|
|
var SubmitAnswerAction: string;
|
|
/**
|
|
* Options for the submit answer action
|
|
*/
|
|
interface ISubmitAnswerOptions extends Core.IActionOptions {
|
|
/**
|
|
* The component the submission is associated with
|
|
*/
|
|
componentId: string;
|
|
/**
|
|
* The attempt the submission is associated with
|
|
*/
|
|
attemptId: string;
|
|
/**
|
|
* The answer being submitted
|
|
*/
|
|
answer: any;
|
|
}
|
|
}
|
|
|
|
|
|
declare module Labs.Core.GetActions {
|
|
/**
|
|
* Gets actions associated with a given component.
|
|
*/
|
|
var GetComponentActions: string;
|
|
/**
|
|
* Options associated with a get component actions
|
|
*/
|
|
interface IGetComponentActionsOptions extends Core.IGetActionOptions {
|
|
/**
|
|
* The component being searched for
|
|
*/
|
|
componentId: string;
|
|
/**
|
|
* The type of action being searched for
|
|
*/
|
|
action: string;
|
|
}
|
|
}
|
|
declare module Labs.Core.GetActions {
|
|
/**
|
|
* Get attempt get action. Retrieves all actions associated with a given attempt.
|
|
*/
|
|
var GetAttempt: string;
|
|
/**
|
|
* Options associated with a get attempt get action.
|
|
*/
|
|
interface IGetAttemptOptions extends Core.IGetActionOptions {
|
|
/**
|
|
* The attempt ID to retrieve all the actions for
|
|
*/
|
|
attemptId: string;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
declare module Labs.Core {
|
|
/**
|
|
* Interface for EventManager callbacks
|
|
*/
|
|
interface IEventCallback {
|
|
(data: any): void;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
var TimelineNextMessageType: string;
|
|
interface ITimelineNextMessage extends Labs.Core.IMessage {
|
|
status: Labs.Core.ICompletionStatus;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Base class for components instances
|
|
*/
|
|
class ComponentInstanceBase {
|
|
/**
|
|
* The ID of the component
|
|
*/
|
|
public _id: string;
|
|
/**
|
|
* The LabsInternal object for use by the component instance
|
|
*/
|
|
public _labs: Labs.LabsInternal;
|
|
constructor();
|
|
/**
|
|
* Attaches a LabsInternal to this component instance
|
|
*
|
|
* @param { id } The ID of the component
|
|
* @param { labs } The LabsInternal object for use by the instance
|
|
*/
|
|
public attach(id: string, labs: Labs.LabsInternal): void;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Class representing a component instance. An instance is an instantiation of a component for a user. It contains
|
|
* a translated view of the component for a particular run of the lab.
|
|
*/
|
|
class ComponentInstance<T> extends Labs.ComponentInstanceBase {
|
|
/**
|
|
* Constructs a new ComponentInstance.
|
|
*/
|
|
constructor();
|
|
/**
|
|
* Begins a new attempt at the component
|
|
*
|
|
* @param { callback } Callback fired when the attempt has been created
|
|
*/
|
|
public createAttempt(callback: Labs.Core.ILabCallback<T>): void;
|
|
/**
|
|
* Retrieves all attempts associated with the given component
|
|
*
|
|
* @param { callback } Callback fired once the attempts have been retrieved
|
|
*/
|
|
public getAttempts(callback: Labs.Core.ILabCallback<T[]>): void;
|
|
/**
|
|
* Retrieves the default create attempt options. Can be overriden by derived classes.
|
|
*/
|
|
public getCreateAttemptOptions(): Labs.Core.Actions.ICreateAttemptOptions;
|
|
/**
|
|
* method to built an attempt from the given action. Should be implemented by derived classes.
|
|
*
|
|
* @param { createAttemptResult } The create attempt action for the attempt
|
|
*/
|
|
public buildAttempt(createAttemptResult: Labs.Core.IAction): T;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Enumeration of the connection states
|
|
*/
|
|
enum ConnectionState {
|
|
/**
|
|
* Disconnected
|
|
*/
|
|
Disconnected,
|
|
/**
|
|
* In the process of connecting
|
|
*/
|
|
Connecting,
|
|
/**
|
|
* Connected
|
|
*/
|
|
Connected,
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Helper class to manage a set of event handlers
|
|
*/
|
|
class EventManager {
|
|
private _handlers;
|
|
private getHandler(event);
|
|
/**
|
|
* Adds a new event handler for the given event
|
|
*
|
|
* @param { event } The event to add a handler for
|
|
* @param { handler } The event handler to add
|
|
*/
|
|
public add(event: string, handler: Labs.Core.IEventCallback): void;
|
|
/**
|
|
* Removes an event handler for the given event
|
|
*
|
|
* @param { event } The event to remove a handler for
|
|
* @param { handler } The event handler to remove
|
|
*/
|
|
public remove(event: string, handler: Labs.Core.IEventCallback): void;
|
|
/**
|
|
* Fires the given event
|
|
*
|
|
* @param { event } The event to fire
|
|
* @param { data } Data associated with the event
|
|
*/
|
|
public fire(event: string, data: any): void;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* The LabEditor allows for the editing of the given lab. This includes getting and setting
|
|
* the entire configuration associated with the lab.
|
|
*/
|
|
class LabEditor {
|
|
private _labsInternal;
|
|
private _doneCallback;
|
|
/**
|
|
* Constructs a new LabEditor
|
|
*
|
|
* @param { labsInternal } LabsInternal to use with the editor
|
|
* @param { doneCallback } Callback to invoke when the editor is finished
|
|
*/
|
|
constructor(labsInternal: Labs.LabsInternal, doneCallback: Function);
|
|
/**
|
|
* Creates a new lab. This prepares the lab storage and saves the host version
|
|
*
|
|
* @param { labsInternal } LabsInternal to use with the editor
|
|
* @param { doneCallback } Callback to invoke when the editor is finished
|
|
* @param { callback } Callback fired once the LabEditor has been created
|
|
*/
|
|
static Create(labsInternal: Labs.LabsInternal, doneCallback: Function, callback: Labs.Core.ILabCallback<LabEditor>): void;
|
|
/**
|
|
* Gets the current lab configuration
|
|
*
|
|
* @param { callback } Callback fired once the configuration has been retrieved
|
|
*/
|
|
public getConfiguration(callback: Labs.Core.ILabCallback<Labs.Core.IConfiguration>): void;
|
|
/**
|
|
* Sets a new lab configuration
|
|
*
|
|
* @param { configuration } The configuration to set
|
|
* @param { callback } Callback fired once the configuration has been set
|
|
*/
|
|
public setConfiguration(configuration: Labs.Core.IConfiguration, callback: Labs.Core.ILabCallback<void>): void;
|
|
/**
|
|
* Indicates that the user is done editing the lab.
|
|
*
|
|
* @param { callback } Callback fired once the lab editor has finished
|
|
*/
|
|
public done(callback: Labs.Core.ILabCallback<void>): void;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* A LabInstance is an instance of the configured lab for the current user. It is used to
|
|
* record and retrieve per user lab data.
|
|
*/
|
|
class LabInstance {
|
|
private _labsInternal;
|
|
private _doneCallback;
|
|
public data: any;
|
|
/**
|
|
* The components that make up the lab instance
|
|
*/
|
|
public components: Labs.ComponentInstanceBase[];
|
|
/**
|
|
* Constructs a new LabInstance
|
|
*
|
|
* @param { labsInternal } The LabsInternal to use with the instance
|
|
* @param { components } The components of the lab instance
|
|
* @param { doneCallback } Callback to invoke once the user is done taking the instance
|
|
* @param { data } Custom data attached to the lab
|
|
*/
|
|
constructor(labsInternal: Labs.LabsInternal, components: Labs.ComponentInstanceBase[], doneCallback: Function, data: any);
|
|
/**
|
|
* Creates a new LabInstance
|
|
*
|
|
* @param { labsInternal } The LabsInternal to use with the instance
|
|
* @param { doneCallback } Callback to invoke once the user is done taking the instance
|
|
* @param { callback } Callback that fires once the LabInstance has been created
|
|
*/
|
|
static Create(labsInternal: Labs.LabsInternal, doneCallback: Function, callback: Labs.Core.ILabCallback<LabInstance>): void;
|
|
/**
|
|
* Gets the current state of the lab for the user
|
|
*
|
|
* @param { callback } Callback that fires with the lab state
|
|
*/
|
|
public getState(callback: Labs.Core.ILabCallback<any>): void;
|
|
/**
|
|
* Sets the state of the lab for the user
|
|
*
|
|
* @param { state } The state to set
|
|
* @param { callback } Callback that fires once the state is set
|
|
*/
|
|
public setState(state: any, callback: Labs.Core.ILabCallback<void>): void;
|
|
/**
|
|
* Indicates that the user is done taking the lab.
|
|
*
|
|
* @param { callback } Callback fired once the lab instance has finished
|
|
*/
|
|
public done(callback: Labs.Core.ILabCallback<void>): void;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Method to use to construct a default ILabHost
|
|
*/
|
|
var DefaultHostBuilder: () => Core.ILabHost;
|
|
/**
|
|
* Initializes a connection with the host.
|
|
*
|
|
* @param { labHost } The (optional) ILabHost to use. If not specified will be constructed with the DefaultHostBuilder
|
|
* @param { callback } Callback to fire once the connection has been established
|
|
*/
|
|
function connect(callback: Core.ILabCallback<Core.IConnectionResponse>);
|
|
function connect(labHost: Core.ILabHost, callback: Core.ILabCallback<Core.IConnectionResponse>);
|
|
/**
|
|
* Returns whether or not the labs are connected to the host.
|
|
*/
|
|
function isConnected(): boolean;
|
|
/**
|
|
* Retrieves the information associated with a connection
|
|
*/
|
|
function getConnectionInfo(): Core.IConnectionResponse;
|
|
/**
|
|
* Disconnects from the host.
|
|
*
|
|
* @param { completionStatus } The final result of the lab interaction
|
|
*/
|
|
function disconnect(): void;
|
|
/**
|
|
* Opens the lab for editing. When in edit mode the configuration can be specified. A lab cannot be edited while it
|
|
* is being taken.
|
|
*
|
|
* @param { callback } Callback fired once the LabEditor is created
|
|
*/
|
|
function editLab(callback: Core.ILabCallback<LabEditor>): void;
|
|
/**
|
|
* Takes the given lab. This allows results to be sent for the lab. A lab cannot be taken while it is being edited.
|
|
*
|
|
* @param { callback } Callback fired once the LabInstance is created
|
|
*/
|
|
function takeLab(callback: Core.ILabCallback<LabInstance>): void;
|
|
/**
|
|
* Adds a new event handler for the given event
|
|
*
|
|
* @param { event } The event to add a handler for
|
|
* @param { handler } The event handler to add
|
|
*/
|
|
function on(event: string, handler: Core.IEventCallback): void;
|
|
/**
|
|
* Removes an event handler for the given event
|
|
*
|
|
* @param { event } The event to remove a handler for
|
|
* @param { handler } The event handler to remove
|
|
*/
|
|
function off(event: string, handler: Core.IEventCallback): void;
|
|
/**
|
|
* Retrieves the Timeline object that can be used to control the host's player control.
|
|
*/
|
|
function getTimeline(): Timeline;
|
|
/**
|
|
* Registers a function to deserialize the given type. Should be used by component authors only.
|
|
*
|
|
* @param { type } The type to deserialize
|
|
* @param { deserialize } The deserialization function
|
|
*/
|
|
function registerDeserializer(type: string, deserialize: (json: Core.ILabObject) => any): void;
|
|
/**
|
|
* Deserializes the given json object into an object. Should be used by component authors only.
|
|
*
|
|
* @param { json } The ILabObject to deserialize
|
|
*/
|
|
function deserialize(json: Core.ILabObject): any;
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Class used to interface with the underlying ILabsHost interface.
|
|
*/
|
|
class LabsInternal {
|
|
/**
|
|
* Current state of the LabsInternal
|
|
*/
|
|
private _state;
|
|
/**
|
|
* The driver to send our commands to
|
|
*/
|
|
private _labHost;
|
|
/**
|
|
* Helper class to manage events in the system
|
|
*/
|
|
private _eventManager;
|
|
/**
|
|
* The cached configuration and state for the lab
|
|
*/
|
|
private _configuration;
|
|
/**
|
|
* The version of the host this LabsInternal is making use of
|
|
*/
|
|
private _hostVersion;
|
|
/**
|
|
* Start out queueing pending messages until we are notified to invoke them
|
|
*/
|
|
private _queuePendingMessages;
|
|
/**
|
|
* Pending messages to invoke from the EventManager
|
|
*/
|
|
private _pendingMessages;
|
|
/**
|
|
* Constructs a new LabsInternal
|
|
*
|
|
* @param { labHost } The ILabHost to make use of
|
|
*/
|
|
constructor(labHost: Labs.Core.ILabHost);
|
|
/**
|
|
* Connect to the host
|
|
*
|
|
* @param { callback } Callback that will return the IConnectionResponse when connected
|
|
*/
|
|
public connect(callback: Labs.Core.ILabCallback<Labs.Core.IConnectionResponse>): void;
|
|
/**
|
|
* Fires all pending messages
|
|
*/
|
|
public firePendingMessages(): void;
|
|
/**
|
|
* Creates a new lab
|
|
*
|
|
* @param { callback } Callback fired once the create operation completes
|
|
*/
|
|
public create(callback: Labs.Core.ILabCallback<void>): void;
|
|
/**
|
|
* Terminates the LabsInternal class and halts the connection.
|
|
*/
|
|
public dispose(): void;
|
|
/**
|
|
* Adds an event handler for the given event
|
|
*
|
|
* @param { event } The event to listen for
|
|
* @param { handler } Handler fired for the given event
|
|
*/
|
|
public on(event: string, handler: Labs.Core.IEventCallback): void;
|
|
/**
|
|
* Sends a message to the host
|
|
*
|
|
* @param { type } The type of message being sent
|
|
* @param { options } The options for that message
|
|
* @param { callback } Callback invoked once the message has been received
|
|
*/
|
|
public sendMessage(type: string, options: Labs.Core.IMessage, callback: Labs.Core.ILabCallback<Labs.Core.IMessageResponse>): void;
|
|
/**
|
|
* Removes an event handler for the given event
|
|
*
|
|
* @param { event } The event whose handler should be removed
|
|
* @param { handler } Handler to remove
|
|
*/
|
|
public off(event: string, handler: Labs.Core.IEventCallback): void;
|
|
/**
|
|
* Gets the current state of the lab for the user
|
|
*
|
|
* @param { callback } Callback that fires when the state is retrieved
|
|
*/
|
|
public getState(callback: Labs.Core.ILabCallback<any>): void;
|
|
/**
|
|
* Sets the state of the lab for the user
|
|
*
|
|
* @param { state } The state to set
|
|
* @param { callback } Callback fired once the state has been set
|
|
*/
|
|
public setState(state: any, callback: Labs.Core.ILabCallback<void>): void;
|
|
/**
|
|
* Gets the current lab configuration
|
|
*
|
|
* @param { callback } Callback that fires when the configuration is retrieved
|
|
*/
|
|
public getConfiguration(callback: Labs.Core.ILabCallback<Labs.Core.IConfiguration>): void;
|
|
/**
|
|
* Sets a new lab configuration
|
|
*
|
|
* @param { configuration } The lab configuration to set
|
|
* @param { callback } Callback that fires once the configuration has been set
|
|
*/
|
|
public setConfiguration(configuration: Labs.Core.IConfiguration, callback: Labs.Core.ILabCallback<void>): void;
|
|
/**
|
|
* Retrieves the configuration instance for the lab.
|
|
*
|
|
* @param { callback } Callback that fires when the configuration instance has been retrieved
|
|
*/
|
|
public getConfigurationInstance(callback: Labs.Core.ILabCallback<Labs.Core.IConfigurationInstance>): void;
|
|
/**
|
|
* Takes an action
|
|
*
|
|
* @param { type } The type of action to take
|
|
* @param { options } The options associated with the action
|
|
* @param { result } The result of the action
|
|
* @param { callback } Callback that fires once the action has completed
|
|
*/
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, callback: Labs.Core.ILabCallback<Labs.Core.IAction>);
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, result: Labs.Core.IActionResult, callback: Labs.Core.ILabCallback<Labs.Core.IAction>);
|
|
/**
|
|
* Retrieves actions
|
|
*
|
|
* @param { type } The type of get to perform
|
|
* @param { options } The options associated with the get
|
|
* @param { callback } Callback that fires with the completed actions
|
|
*/
|
|
public getActions(type: string, options: Labs.Core.IGetActionOptions, callback: Labs.Core.ILabCallback<Labs.Core.IAction[]>): void;
|
|
/**
|
|
* Checks whether or not the LabsInternal is initialized
|
|
*/
|
|
private checkIsInitialized();
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Provides access to the labs.js timeline
|
|
*/
|
|
class Timeline {
|
|
private _labsInternal;
|
|
constructor(labsInternal: Labs.LabsInternal);
|
|
/**
|
|
* Used to indicate that the timeline should advance to the next slide.
|
|
*/
|
|
public next(completionStatus: Labs.Core.ICompletionStatus, callback: Labs.Core.ILabCallback<void>): void;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* A ValueHolder is responsible for holding a value that when requested is tracked by labs.js.
|
|
* This value may be stored locally or stored on the server.
|
|
*/
|
|
class ValueHolder<T> {
|
|
/**
|
|
* The component the value is associated with
|
|
*/
|
|
private _componentId;
|
|
/**
|
|
* Attempt the value is associated with
|
|
*/
|
|
private _attemptId;
|
|
/**
|
|
* Underlying labs device
|
|
*/
|
|
private _labs;
|
|
/**
|
|
* Whether or not the value is a hint
|
|
*/
|
|
public isHint: boolean;
|
|
/**
|
|
* Whether or not the value has been requested.
|
|
*/
|
|
public hasBeenRequested: boolean;
|
|
/**
|
|
* Whether or not the value holder currently has the value.
|
|
*/
|
|
public hasValue: boolean;
|
|
/**
|
|
* The value held by the holder.
|
|
*/
|
|
public value: T;
|
|
/**
|
|
* The ID for the value
|
|
*/
|
|
public id: string;
|
|
/**
|
|
* Constructs a new ValueHolder
|
|
*
|
|
* @param { componentId } The component the value is associated with
|
|
* @param { attemptId } The attempt the value is associated with
|
|
* @param { id } The id of the value
|
|
* @param { labs } The labs device that can be used to request the value
|
|
* @param { isHint } Whether or not the value is a hint
|
|
* @param { hasBeenRequested } Whether or not the value has already been requested
|
|
* @param { hasValue } Whether or not the value is available
|
|
* @param { value } If hasValue is true this is the value, otherwise is optional
|
|
*/
|
|
constructor(componentId: string, attemptId: string, id: string, labs: Labs.LabsInternal, isHint: boolean, hasBeenRequested: boolean, hasValue: boolean, value?: T);
|
|
/**
|
|
* Retrieves the given value
|
|
*
|
|
* @param { callback } Callback that returns the given value
|
|
*/
|
|
public getValue(callback: Labs.Core.ILabCallback<T>): void;
|
|
/**
|
|
* Internal method used to actually provide a value to the value holder
|
|
*
|
|
* @param { value } The value to set for the holder
|
|
*/
|
|
public provideValue(value: T): void;
|
|
}
|
|
}
|
|
|
|
|
|
declare module Labs.Components {
|
|
/**
|
|
* Base class for attempts
|
|
*/
|
|
class ComponentAttempt {
|
|
public _componentId: string;
|
|
public _id: string;
|
|
public _labs: Labs.LabsInternal;
|
|
public _resumed: boolean;
|
|
public _state: Labs.ProblemState;
|
|
public _values: {
|
|
[type: string]: Labs.ValueHolder<any>[];
|
|
};
|
|
/**
|
|
* Constructs a new ComponentAttempt.
|
|
*
|
|
* @param { labs } The LabsInternal to use with the attempt
|
|
* @param { attemptId } The ID associated with the attempt
|
|
* @param { values } The values associated with the attempt
|
|
*/
|
|
constructor(labs: Labs.LabsInternal, componentId: string, attemptId: string, values: {
|
|
[type: string]: Labs.Core.IValueInstance[];
|
|
});
|
|
/**
|
|
* Verifies that the attempt has been resumed
|
|
*/
|
|
public verifyResumed(): void;
|
|
/**
|
|
* Returns whether or not the app has been resumed
|
|
*/
|
|
public isResumed(): boolean;
|
|
/**
|
|
* Used to indicate that the lab has resumed progress on the given attempt. Loads in existing data as part of this process. An attempt
|
|
* must be resumed before it can be used.
|
|
*
|
|
* @param { callback } Callback fired once the attempt is resumed
|
|
*/
|
|
public resume(callback: Labs.Core.ILabCallback<void>): void;
|
|
/**
|
|
* Helper method to send the resume action to the host
|
|
*/
|
|
private sendResumeAction(callback);
|
|
/**
|
|
* Runs over the retrieved actions for the attempt and populates the state of the lab
|
|
*/
|
|
private resumeCore(actions);
|
|
/**
|
|
* Retrieves the state of the lab
|
|
*/
|
|
public getState(): Labs.ProblemState;
|
|
public processAction(action: Labs.Core.IAction): void;
|
|
/**
|
|
* Retrieves the cached values associated with the attempt
|
|
*
|
|
* @param { key } The key to lookup in the value map
|
|
*/
|
|
public getValues(key: string): Labs.ValueHolder<any>[];
|
|
/**
|
|
* Makes use of a value in the value array
|
|
*/
|
|
private useValue(completedSubmission);
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* A class representing an attempt at an activity component
|
|
*/
|
|
class ActivityComponentAttempt extends Components.ComponentAttempt {
|
|
constructor(labs: Labs.LabsInternal, componentId: string, attemptId: string, values: {
|
|
[type: string]: Labs.Core.IValueInstance[];
|
|
});
|
|
/**
|
|
* Called to indicate that the activity has completed
|
|
*
|
|
* @param { callback } Callback invoked once the activity has completed
|
|
*/
|
|
public complete(callback: Labs.Core.ILabCallback<void>): void;
|
|
/**
|
|
* Runs over the retrieved actions for the attempt and populates the state of the lab
|
|
*/
|
|
public processAction(action: Labs.Core.IAction): void;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
var ActivityComponentInstanceType: string;
|
|
class ActivityComponentInstance extends Labs.ComponentInstance<Components.ActivityComponentAttempt> {
|
|
/**
|
|
* The underlying IActivityComponentInstance this class represents
|
|
*/
|
|
public component: Components.IActivityComponentInstance;
|
|
/**
|
|
* Constructs a new ActivityComponentInstnace
|
|
*
|
|
* @param { component } The IActivityComponentInstance to create this class from
|
|
*/
|
|
constructor(component: Components.IActivityComponentInstance);
|
|
/**
|
|
* Builds a new ActivityComponentAttempt. Implements abstract method defined on the base class.
|
|
*
|
|
* @param { createAttemptResult } The result from a create attempt action
|
|
*/
|
|
public buildAttempt(createAttemptAction: Labs.Core.IAction): Components.ActivityComponentAttempt;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* Answer to a choice component problem
|
|
*/
|
|
class ChoiceComponentAnswer {
|
|
/**
|
|
* The answer value
|
|
*/
|
|
public answer: any;
|
|
/**
|
|
* Constructs a new ChoiceComponentAnswer
|
|
*/
|
|
constructor(answer: any);
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* A class representing an attempt at a choice component
|
|
*/
|
|
class ChoiceComponentAttempt extends Components.ComponentAttempt {
|
|
private _submissions;
|
|
/**
|
|
* Constructs a new ChoiceComponentAttempt.
|
|
*
|
|
* @param { labs } The LabsInternal to use with the attempt
|
|
* @param { attemptId } The ID associated with the attempt
|
|
* @param { values } The values associated with the attempt
|
|
*/
|
|
constructor(labs: Labs.LabsInternal, componentId: string, attemptId: string, values: {
|
|
[type: string]: Labs.Core.IValueInstance[];
|
|
});
|
|
/**
|
|
* Used to mark that the lab has timed out
|
|
*
|
|
* @param { callback } Callback fired once the server has received the timeout message
|
|
*/
|
|
public timeout(callback: Labs.Core.ILabCallback<void>): void;
|
|
/**
|
|
* Retrieves all of the submissions that have previously been submitted for the given attempt
|
|
*/
|
|
public getSubmissions(): Components.ChoiceComponentSubmission[];
|
|
/**
|
|
* Submits a new answer that was graded by the lab and will not use the host to compute a grade.
|
|
*
|
|
* @param { answer } The answer for the attempt
|
|
* @param { result } The result of the submission
|
|
* @param { callback } Callback fired once the submission has been received
|
|
*/
|
|
public submit(answer: Components.ChoiceComponentAnswer, result: Components.ChoiceComponentResult, callback: Labs.Core.ILabCallback<Components.ChoiceComponentSubmission>): void;
|
|
public processAction(action: Labs.Core.IAction): void;
|
|
/**
|
|
* Helper method used to handle a returned submission from labs core
|
|
*/
|
|
private storeSubmission(completedSubmission);
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* The name of the component instance. A choice component is a component that has multiple choice options and supports zero
|
|
* or more responses. Optionally there is a correct list of choices.
|
|
*/
|
|
var ChoiceComponentInstanceType: string;
|
|
/**
|
|
* Class representing a choice component instance
|
|
*/
|
|
class ChoiceComponentInstance extends Labs.ComponentInstance<Components.ChoiceComponentAttempt> {
|
|
/**
|
|
* The underlying IChoiceComponentInstance this class represents
|
|
*/
|
|
public component: Components.IChoiceComponentInstance;
|
|
/**
|
|
* Constructs a new ChoiceComponentInstance
|
|
*
|
|
* @param { component } The IChoiceComponentInstance to create this class from
|
|
*/
|
|
constructor(component: Components.IChoiceComponentInstance);
|
|
/**
|
|
* Builds a new ChoiceComponentAttempt. Implements abstract method defined on the base class.
|
|
*
|
|
* @param { createAttemptResult } The result from a create attempt action
|
|
*/
|
|
public buildAttempt(createAttemptAction: Labs.Core.IAction): Components.ChoiceComponentAttempt;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* The name of the component instance. A dynamic component is a component that allows for new components to be inserted within it.
|
|
*/
|
|
var DynamicComponentInstanceType: string;
|
|
/**
|
|
* Class representing a dynamic component. A dynamic component is used to create, at runtime, new components.
|
|
*/
|
|
class DynamicComponentInstance extends Labs.ComponentInstanceBase {
|
|
public component: Components.IDynamicComponentInstance;
|
|
/**
|
|
* Constructs a new dynamic component instance from the provided definition
|
|
*/
|
|
constructor(component: Components.IDynamicComponentInstance);
|
|
/**
|
|
* Retrieves all the components created by this dynamic component.
|
|
*/
|
|
public getComponents(callback: Labs.Core.ILabCallback<Labs.ComponentInstanceBase[]>): void;
|
|
/**
|
|
* Creates a new component.
|
|
*/
|
|
public createComponent(component: Labs.Core.IComponent, callback: Labs.Core.ILabCallback<Labs.ComponentInstanceBase>): void;
|
|
private createComponentInstance(action);
|
|
/**
|
|
* Used to indicate that there will be no more submissions associated with this component
|
|
*/
|
|
public close(callback: Labs.Core.ILabCallback<void>): void;
|
|
/**
|
|
* Returns whether or not the dynamic component is closed
|
|
*/
|
|
public isClosed(callback: Labs.Core.ILabCallback<boolean>): void;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* Type string for an ActivityComponent
|
|
*/
|
|
var ActivityComponentType: string;
|
|
/**
|
|
* An activity component is simply an activity for the taker to experience. Examples are viewing a web page
|
|
* or watching a video.
|
|
*/
|
|
interface IActivityComponent extends Labs.Core.IComponent {
|
|
/**
|
|
* Whether or not the input component is secure. This is not yet implemented.
|
|
*/
|
|
secure: boolean;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
interface IActivityComponentInstance extends Labs.Core.IComponentInstance {
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* A choice for a problem
|
|
*/
|
|
interface IChoice {
|
|
/**
|
|
* Unique id to represent the choice
|
|
*/
|
|
id: string;
|
|
/**
|
|
* Display string to use to represent the value
|
|
* I think I should put this into the value type - have default ones show up - and then have custom values within
|
|
*/
|
|
name: string;
|
|
/**
|
|
* The value of the choice
|
|
*/
|
|
value: any;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* Type string to use with this type of component
|
|
*/
|
|
var ChoiceComponentType: string;
|
|
/**
|
|
* A choice problem is a problem type where the user is presented with a list of choices and then needs to select
|
|
* an answer from them.
|
|
*/
|
|
interface IChoiceComponent extends Labs.Core.IComponent {
|
|
/**
|
|
* The list of choices associated with the problem
|
|
*/
|
|
choices: Components.IChoice[];
|
|
/**
|
|
* A time limit for the problem
|
|
*/
|
|
timeLimit: number;
|
|
/**
|
|
* The maximum number of attempts allowed for the problem
|
|
*/
|
|
maxAttempts: number;
|
|
/**
|
|
* The max score for the problem
|
|
*/
|
|
maxScore: number;
|
|
/**
|
|
* Whether or not this problem has an answer
|
|
*/
|
|
hasAnswer: boolean;
|
|
/**
|
|
* The answer. Either an array if multiple answers are supported or a single ID if only one answer is supported.
|
|
*/
|
|
answer: any;
|
|
/**
|
|
* Whether or not the quiz is secure - meaning that secure fields are held from the user.
|
|
* This is not yet implemented.
|
|
*/
|
|
secure: boolean;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* An instance of a choice component
|
|
*/
|
|
interface IChoiceComponentInstance extends Labs.Core.IComponentInstance {
|
|
/**
|
|
* The list of choices associated with the problem
|
|
*/
|
|
choices: Components.IChoice[];
|
|
/**
|
|
* A time limit for the problem
|
|
*/
|
|
timeLimit: number;
|
|
/**
|
|
* The maximum number of attempts allowed for the problem
|
|
*/
|
|
maxAttempts: number;
|
|
/**
|
|
* The max score for the problem
|
|
*/
|
|
maxScore: number;
|
|
/**
|
|
* Whether or not this problem has an answer
|
|
*/
|
|
hasAnswer: boolean;
|
|
/**
|
|
* The answer. Either an array if multiple answers are supported or a single ID if only one answe is supported.
|
|
*/
|
|
answer: any;
|
|
/**
|
|
* Whether or not the quiz is secure - meaning that secure fields are held from the user
|
|
*/
|
|
secure: boolean;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
var Infinite: number;
|
|
/**
|
|
* Type string for a dynamic component
|
|
*/
|
|
var DynamicComponentType: string;
|
|
/**
|
|
* A dynamic component represents one that can generate other components at runtime.
|
|
* This can be used for branching questions, dynamically generated ones, etc...
|
|
*/
|
|
interface IDynamicComponent extends Labs.Core.IComponent {
|
|
/**
|
|
* An array containing the types of components this dynamic component may generate
|
|
*/
|
|
generatedComponentTypes: string[];
|
|
/**
|
|
* The maximum number of components that will be generated by this DynamicComponent. Or Labs.Components.Infinite if
|
|
* there is no cap.
|
|
*/
|
|
maxComponents: number;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* An instance of a dynamic component.
|
|
*/
|
|
interface IDynamicComponentInstance extends Labs.Core.IComponentInstance {
|
|
/**
|
|
* An array containing the types of components this dynamic component may generate
|
|
*/
|
|
generatedComponentTypes: string[];
|
|
/**
|
|
* The maximum number of components that will be generated by this DynamicComponent. Or Labs.Components.Infinite if
|
|
* there is no cap.
|
|
*/
|
|
maxComponents: number;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* A hint in a lab
|
|
*/
|
|
interface IHint extends Labs.Core.IValue {
|
|
/**
|
|
* Display value to use for the hint
|
|
*/
|
|
name: string;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* Type string to use with this type of component
|
|
*/
|
|
var InputComponentType: string;
|
|
/**
|
|
* An input problem is one in which the user enters an input which is checked against a correct value.
|
|
*/
|
|
interface IInputComponent extends Labs.Core.IComponent {
|
|
/**
|
|
* The max score for the input component
|
|
*/
|
|
maxScore: number;
|
|
/**
|
|
* Time limit associated with the input problem
|
|
*/
|
|
timeLimit: number;
|
|
/**
|
|
* Whether or not the component has an answer
|
|
*/
|
|
hasAnswer: boolean;
|
|
/**
|
|
* The answer to the component (if it exists)
|
|
*/
|
|
answer: any;
|
|
/**
|
|
* Whether or not the input component is secure. This is not yet implemented.
|
|
*/
|
|
secure: boolean;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* An input problem is one in which the user enters an input which is checked against a correct value.
|
|
*/
|
|
interface IInputComponentInstance extends Labs.Core.IComponentInstance {
|
|
/**
|
|
* The max score for the input component
|
|
*/
|
|
maxScore: number;
|
|
/**
|
|
* Time limit associated with the input problem
|
|
*/
|
|
timeLimit: number;
|
|
/**
|
|
* The answer to the component
|
|
*/
|
|
answer: any;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* Answer to an input component problem
|
|
*/
|
|
class InputComponentAnswer {
|
|
/**
|
|
* The answer value
|
|
*/
|
|
public answer: any;
|
|
/**
|
|
* Constructs a new InputComponentAnswer
|
|
*/
|
|
constructor(answer: any);
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* A class representing an attempt at an input component
|
|
*/
|
|
class InputComponentAttempt extends Components.ComponentAttempt {
|
|
private _submissions;
|
|
constructor(labs: Labs.LabsInternal, componentId: string, attemptId: string, values: {
|
|
[type: string]: Labs.Core.IValueInstance[];
|
|
});
|
|
/**
|
|
* Runs over the retrieved actions for the attempt and populates the state of the lab
|
|
*/
|
|
public processAction(action: Labs.Core.IAction): void;
|
|
/**
|
|
* Retrieves all of the submissions that have previously been submitted for the given attempt
|
|
*/
|
|
public getSubmissions(): Components.InputComponentSubmission[];
|
|
/**
|
|
* Submits a new answer that was graded by the lab and will not use the host to compute a grade.
|
|
*
|
|
* @param { answer } The answer for the attempt
|
|
* @param { result } The result of the submission
|
|
* @param { callback } Callback fired once the submission has been received
|
|
*/
|
|
public submit(answer: Components.InputComponentAnswer, result: Components.InputComponentResult, callback: Labs.Core.ILabCallback<Components.InputComponentSubmission>): void;
|
|
/**
|
|
* Helper method used to handle a returned submission from labs core
|
|
*/
|
|
private storeSubmission(completedSubmission);
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* The name of the component instance. An input component is a component that allows free form
|
|
* input from a user.
|
|
*/
|
|
var InputComponentInstanceType: string;
|
|
/**
|
|
* Class representing an input component instance
|
|
*/
|
|
class InputComponentInstance extends Labs.ComponentInstance<Components.InputComponentAttempt> {
|
|
/**
|
|
* The underlying IInputComponentInstance this class represents
|
|
*/
|
|
public component: Components.IInputComponentInstance;
|
|
/**
|
|
* Constructs a new InputComponentInstance
|
|
*
|
|
* @param { component } The IInputComponentInstance to create this class from
|
|
*/
|
|
constructor(component: Components.IInputComponentInstance);
|
|
/**
|
|
* Builds a new InputComponentAttempt. Implements abstract method defined on the base class.
|
|
*
|
|
* @param { createAttemptResult } The result from a create attempt action
|
|
*/
|
|
public buildAttempt(createAttemptAction: Labs.Core.IAction): Components.InputComponentAttempt;
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* The result of an input component submission
|
|
*/
|
|
class InputComponentResult {
|
|
/**
|
|
* The score associated with the submission
|
|
*/
|
|
public score: any;
|
|
/**
|
|
* Whether or not the result resulted in the completion of the attempt
|
|
*/
|
|
public complete: boolean;
|
|
/**
|
|
* Constructs a new InputComponentResult
|
|
*
|
|
* @param { score } The score of the result
|
|
* @param { complete } Whether or not the result completed the attempt
|
|
*/
|
|
constructor(score: any, complete: boolean);
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* Class that represents an input component submission
|
|
*/
|
|
class InputComponentSubmission {
|
|
/**
|
|
* The answer associated with the submission
|
|
*/
|
|
public answer: Components.InputComponentAnswer;
|
|
/**
|
|
* The result of the submission
|
|
*/
|
|
public result: Components.InputComponentResult;
|
|
/**
|
|
* The time at which the submission was received
|
|
*/
|
|
public time: number;
|
|
/**
|
|
* Constructs a new InputComponentSubmission
|
|
*
|
|
* @param { answer } The answer associated with the submission
|
|
* @param { result } The result of the submission
|
|
* @param { time } The time at which the submission was received
|
|
*/
|
|
constructor(answer: Components.InputComponentAnswer, result: Components.InputComponentResult, time: number);
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* State values for a lab
|
|
*/
|
|
enum ProblemState {
|
|
/**
|
|
* The problem is in progress
|
|
*/
|
|
InProgress,
|
|
/**
|
|
* The problem has timed out
|
|
*/
|
|
Timeout,
|
|
/**
|
|
* The problem has completed
|
|
*/
|
|
Completed,
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* The result of a choice component submission
|
|
*/
|
|
class ChoiceComponentResult {
|
|
/**
|
|
* The score associated with the submission
|
|
*/
|
|
public score: any;
|
|
/**
|
|
* Whether or not the result resulted in the completion of the attempt
|
|
*/
|
|
public complete: boolean;
|
|
/**
|
|
* Constructs a new ChoiceComponentResult
|
|
*
|
|
* @param { score } The score of the result
|
|
* @param { complete } Whether or not the result completed the attempt
|
|
*/
|
|
constructor(score: any, complete: boolean);
|
|
}
|
|
}
|
|
declare module Labs.Components {
|
|
/**
|
|
* Class that represents a choice component submission
|
|
*/
|
|
class ChoiceComponentSubmission {
|
|
/**
|
|
* The answer associated with the submission
|
|
*/
|
|
public answer: Components.ChoiceComponentAnswer;
|
|
/**
|
|
* The result of the submission
|
|
*/
|
|
public result: Components.ChoiceComponentResult;
|
|
/**
|
|
* The time at which the submission was received
|
|
*/
|
|
public time: number;
|
|
/**
|
|
* Constructs a new ChoiceComponentSubmission
|
|
*
|
|
* @param { answer } The answer associated with the submission
|
|
* @param { result } The result of the submission
|
|
* @param { time } The time at which the submission was received
|
|
*/
|
|
constructor(answer: Components.ChoiceComponentAnswer, result: Components.ChoiceComponentResult, time: number);
|
|
}
|
|
}
|
|
|
|
|
|
declare module Labs {
|
|
/**
|
|
* General command used to pass messages between the client and host
|
|
*/
|
|
class Command {
|
|
public type: string;
|
|
public commandData: any;
|
|
/**
|
|
* Constructs a new command
|
|
*
|
|
* @param { type } The type of command
|
|
* @param { commandData } Optional data associated with the command
|
|
*/
|
|
constructor(type: string, commandData?: any);
|
|
}
|
|
}
|
|
/**
|
|
* Strings representing supported command types
|
|
*/
|
|
declare module Labs.CommandType {
|
|
var Connect: string;
|
|
var Disconnect: string;
|
|
var Create: string;
|
|
var GetConfigurationInstance: string;
|
|
var TakeAction: string;
|
|
var GetCompletedActions: string;
|
|
var ModeChanged: string;
|
|
var GetConfiguration: string;
|
|
var SetConfiguration: string;
|
|
var GetState: string;
|
|
var SetState: string;
|
|
var SendMessage: string;
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Static class containing the different event types.
|
|
*/
|
|
class EventTypes {
|
|
/**
|
|
* Mode changed event type. Fired whenever the lab mode is changed.
|
|
*/
|
|
static ModeChanged: string;
|
|
/**
|
|
* Event invoked when the app becomes active.
|
|
*/
|
|
static Activate: string;
|
|
/**
|
|
* Event invoked when the app is deactivated
|
|
*/
|
|
static Deactivate: string;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Command data associated with a GetActions command
|
|
*/
|
|
interface GetActionsCommandData {
|
|
/**
|
|
* The type of get
|
|
*/
|
|
type: string;
|
|
/**
|
|
* Options for the get command
|
|
*/
|
|
options: Labs.Core.IGetActionOptions;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Type of message being sent over the wire
|
|
*/
|
|
enum MessageType {
|
|
Message,
|
|
Completion,
|
|
Failure,
|
|
}
|
|
/**
|
|
* The message being sent
|
|
*/
|
|
class Message {
|
|
public id: number;
|
|
public labId: string;
|
|
public type: MessageType;
|
|
public payload: any;
|
|
constructor(id: number, labId: string, type: MessageType, payload: any);
|
|
}
|
|
/**
|
|
* Interface for defining event handlers
|
|
*/
|
|
interface IMessageHandler {
|
|
(origin: Window, data: any, callback: Labs.Core.ILabCallback<any>): void;
|
|
}
|
|
class MessageProcessor {
|
|
public isStarted: boolean;
|
|
public eventListener: EventListener;
|
|
public nextMessageId: number;
|
|
private messageMap;
|
|
public targetOrigin: string;
|
|
public messageHandler: IMessageHandler;
|
|
private _labId;
|
|
constructor(labId: string, targetOrigin: string, messageHandler: IMessageHandler);
|
|
private throwIfNotStarted();
|
|
private getNextMessageId();
|
|
private parseOrigin(href);
|
|
private listener(event);
|
|
private postMessage(targetWindow, message);
|
|
public start(): void;
|
|
public stop(): void;
|
|
public sendMessage(targetWindow: Window, data: any, callback: Labs.Core.ILabCallback<any>): void;
|
|
}
|
|
}
|
|
declare module Labs.Core {
|
|
/**
|
|
* Data associated with a mode changed event
|
|
*/
|
|
interface ModeChangedEventData {
|
|
/**
|
|
* The mode being set
|
|
*/
|
|
mode: string;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Data associated with a take action command
|
|
*/
|
|
interface SendMessageCommandData {
|
|
/**
|
|
* The type of message
|
|
*/
|
|
type: string;
|
|
/**
|
|
* Options associated with the message
|
|
*/
|
|
options: Labs.Core.IMessage;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* Data associated with a take action command
|
|
*/
|
|
interface TakeActionCommandData {
|
|
/**
|
|
* The type of action
|
|
*/
|
|
type: string;
|
|
/**
|
|
* Options associated with the action
|
|
*/
|
|
options: Labs.Core.IActionOptions;
|
|
/**
|
|
* The result of the action
|
|
*/
|
|
result: Labs.Core.IActionResult;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
declare module Labs {
|
|
interface IHostMessage {
|
|
type: string;
|
|
options: Labs.Core.IMessage;
|
|
response: Labs.Core.IMessageResponse;
|
|
}
|
|
class InMemoryLabHost implements Labs.Core.ILabHost {
|
|
private _version;
|
|
private _labState;
|
|
private _messages;
|
|
constructor(version: Labs.Core.IVersion);
|
|
public getSupportedVersions(): Labs.Core.ILabHostVersionInfo[];
|
|
public connect(versions: Labs.Core.ILabHostVersionInfo[], callback: Labs.Core.ILabCallback<Labs.Core.IConnectionResponse>): void;
|
|
public disconnect(callback: Labs.Core.ILabCallback<void>): void;
|
|
public on(handler: (string: any, any: any) => void): void;
|
|
public sendMessage(type: string, options: Labs.Core.IMessage, callback: Labs.Core.ILabCallback<Labs.Core.IMessageResponse>): void;
|
|
public getMessages(): IHostMessage[];
|
|
public create(options: Labs.Core.ILabCreationOptions, callback: Labs.Core.ILabCallback<void>): void;
|
|
public getConfiguration(callback: Labs.Core.ILabCallback<Labs.Core.IConfiguration>): void;
|
|
public setConfiguration(configuration: Labs.Core.IConfiguration, callback: Labs.Core.ILabCallback<void>): void;
|
|
public getState(callback: Labs.Core.ILabCallback<any>): void;
|
|
public setState(state: any, callback: Labs.Core.ILabCallback<void>): void;
|
|
public getConfigurationInstance(callback: Labs.Core.ILabCallback<Labs.Core.IConfigurationInstance>): void;
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, callback: Labs.Core.ILabCallback<Labs.Core.IAction>);
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, result: Labs.Core.IActionResult, callback: Labs.Core.ILabCallback<Labs.Core.IAction>);
|
|
public getActions(type: string, options: Labs.Core.IGetActionOptions, callback: Labs.Core.ILabCallback<Labs.Core.IAction[]>): void;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
class InMemoryLabState {
|
|
private _configuration;
|
|
private _configurationInstance;
|
|
private _state;
|
|
private _actions;
|
|
private _nextId;
|
|
private _componentInstances;
|
|
constructor();
|
|
public getConfiguration(): Labs.Core.IConfiguration;
|
|
public setConfiguration(configuration: Labs.Core.IConfiguration): void;
|
|
public getState(): any;
|
|
public setState(state: any): void;
|
|
public getConfigurationInstance(): Labs.Core.IConfigurationInstance;
|
|
private getConfigurationInstanceFromConfiguration(configuration);
|
|
private getAndStoreComponentInstanceFromComponent(component);
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, result: any): Labs.Core.IAction;
|
|
private takeActionCore(type, options, result);
|
|
private findConfigurationValue(componentId, attemptId, valueId);
|
|
public getAllActions(): Labs.Core.IAction[];
|
|
public setActions(actions: Labs.Core.IAction[]): void;
|
|
public getActions(type: string, options: Labs.Core.IGetActionOptions): Labs.Core.IAction[];
|
|
}
|
|
}
|
|
interface OfficeInterface {
|
|
initialize: any;
|
|
context: any;
|
|
AsyncResultStatus: any;
|
|
Index: any;
|
|
GoToType: any;
|
|
}
|
|
declare var Office: OfficeInterface;
|
|
declare module Labs {
|
|
interface IPromise {
|
|
then(callback: Function);
|
|
}
|
|
class Resolver {
|
|
private _callbacks;
|
|
private _isResolved;
|
|
private _resolvedValue;
|
|
public promise: IPromise;
|
|
constructor();
|
|
public resolve(value?: any): void;
|
|
private fireCallbacks();
|
|
}
|
|
interface ILabsSettings {
|
|
/**
|
|
* The lab configuration
|
|
*/
|
|
configuration?: Labs.Core.IConfiguration;
|
|
/**
|
|
* The version of the host used to create the lab
|
|
*/
|
|
hostVersion?: Labs.Core.IVersion;
|
|
/**
|
|
* Boolean that is set to true when the lab is published
|
|
*/
|
|
published?: boolean;
|
|
/**
|
|
* The published ID of the lab
|
|
*/
|
|
publishedAppId?: string;
|
|
}
|
|
class OfficeJSLabHost implements Labs.Core.ILabHost {
|
|
private _officeInitialized;
|
|
private _labHost;
|
|
private _version;
|
|
static SettingsKeyName: string;
|
|
constructor();
|
|
public getSupportedVersions(): Labs.Core.ILabHostVersionInfo[];
|
|
public connect(versions: Labs.Core.ILabHostVersionInfo[], callback: Labs.Core.ILabCallback<Labs.Core.IConnectionResponse>): void;
|
|
public disconnect(callback: Labs.Core.ILabCallback<void>): void;
|
|
public on(handler: (string: any, any: any) => void): void;
|
|
public sendMessage(type: string, options: Labs.Core.IMessage, callback: Labs.Core.ILabCallback<Labs.Core.IMessageResponse>): void;
|
|
public create(options: Labs.Core.ILabCreationOptions, callback: Labs.Core.ILabCallback<void>): void;
|
|
public getConfiguration(callback: Labs.Core.ILabCallback<Labs.Core.IConfiguration>): void;
|
|
public setConfiguration(configuration: Labs.Core.IConfiguration, callback: Labs.Core.ILabCallback<void>): void;
|
|
public getConfigurationInstance(callback: Labs.Core.ILabCallback<Labs.Core.IConfigurationInstance>): void;
|
|
public getState(callback: Labs.Core.ILabCallback<any>): void;
|
|
public setState(state: any, callback: Labs.Core.ILabCallback<void>): void;
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, callback: Labs.Core.ILabCallback<Labs.Core.IAction>);
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, result: Labs.Core.IActionResult, callback: Labs.Core.ILabCallback<Labs.Core.IAction>);
|
|
public getActions(type: string, options: Labs.Core.IGetActionOptions, callback: Labs.Core.ILabCallback<Labs.Core.IAction[]>): void;
|
|
}
|
|
}
|
|
declare module Labs {
|
|
/**
|
|
* PostMessageLabHost - ILabHost that uses PostMessage for its communication mechanism
|
|
*/
|
|
class PostMessageLabHost implements Labs.Core.ILabHost {
|
|
private _handlers;
|
|
private _messageProcessor;
|
|
private _version;
|
|
private _targetWindow;
|
|
private _state;
|
|
private _deferredEvents;
|
|
constructor(labId: string, targetWindow: Window, targetOrigin: string);
|
|
private handleEvent(command, callback);
|
|
private invokeDeferredEvents(err);
|
|
private invokeEvent(err, command, callback);
|
|
public getSupportedVersions(): Labs.Core.ILabHostVersionInfo[];
|
|
public connect(versions: Labs.Core.ILabHostVersionInfo[], callback: Labs.Core.ILabCallback<Labs.Core.IConnectionResponse>): void;
|
|
public disconnect(callback: Labs.Core.ILabCallback<void>): void;
|
|
public on(handler: (string: any, any: any) => void): void;
|
|
public sendMessage(type: string, options: Labs.Core.IMessage, callback: Labs.Core.ILabCallback<Labs.Core.IMessageResponse>): void;
|
|
public create(options: Labs.Core.ILabCreationOptions, callback: Labs.Core.ILabCallback<void>): void;
|
|
public getConfiguration(callback: Labs.Core.ILabCallback<Labs.Core.IConfiguration>): void;
|
|
public setConfiguration(configuration: Labs.Core.IConfiguration, callback: Labs.Core.ILabCallback<void>): void;
|
|
public getConfigurationInstance(callback: Labs.Core.ILabCallback<Labs.Core.IConfigurationInstance>): void;
|
|
public getState(callback: Labs.Core.ILabCallback<any>): void;
|
|
public setState(state: any, callback: Labs.Core.ILabCallback<void>): void;
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, callback: Labs.Core.ILabCallback<Labs.Core.IAction>);
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, result: Labs.Core.IActionResult, callback: Labs.Core.ILabCallback<Labs.Core.IAction>);
|
|
public getActions(type: string, options: Labs.Core.IGetActionOptions, callback: Labs.Core.ILabCallback<Labs.Core.IAction[]>): void;
|
|
private sendCommand(command, callback);
|
|
}
|
|
}
|
|
declare module Labs {
|
|
class RichClientOfficeJSLabsHost implements Labs.Core.ILabHost {
|
|
private _handlers;
|
|
private _activeMode;
|
|
private _version;
|
|
private _labState;
|
|
private _createdHostVersion;
|
|
private _activeViewP;
|
|
constructor(configuration: Labs.Core.IConfiguration, createdHostVersion: Labs.Core.IVersion);
|
|
private getLabModeFromActiveView(view);
|
|
public getSupportedVersions(): Labs.Core.ILabHostVersionInfo[];
|
|
public connect(versions: Labs.Core.ILabHostVersionInfo[], callback: Labs.Core.ILabCallback<Labs.Core.IConnectionResponse>): void;
|
|
public disconnect(callback: Labs.Core.ILabCallback<void>): void;
|
|
public on(handler: (string: any, any: any) => void): void;
|
|
public sendMessage(type: string, options: Labs.Core.IMessage, callback: Labs.Core.ILabCallback<Labs.Core.IMessageResponse>): void;
|
|
public create(options: Labs.Core.ILabCreationOptions, callback: Labs.Core.ILabCallback<void>): void;
|
|
public getConfiguration(callback: Labs.Core.ILabCallback<Labs.Core.IConfiguration>): void;
|
|
public setConfiguration(configuration: Labs.Core.IConfiguration, callback: Labs.Core.ILabCallback<void>): void;
|
|
private updateStoredLabsState(callback);
|
|
public getConfigurationInstance(callback: Labs.Core.ILabCallback<Labs.Core.IConfigurationInstance>): void;
|
|
public getState(callback: Labs.Core.ILabCallback<any>): void;
|
|
public setState(state: any, callback: Labs.Core.ILabCallback<void>): void;
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, callback: Labs.Core.ILabCallback<Labs.Core.IAction>);
|
|
public takeAction(type: string, options: Labs.Core.IActionOptions, result: Labs.Core.IActionResult, callback: Labs.Core.ILabCallback<Labs.Core.IAction>);
|
|
public getActions(type: string, options: Labs.Core.IGetActionOptions, callback: Labs.Core.ILabCallback<Labs.Core.IAction[]>): void;
|
|
}
|
|
}
|