botbuilder-dialogs
Version:
A dialog stack based conversation manager for Microsoft BotBuilder.
288 lines • 12.8 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Prompt = exports.ListStyle = void 0;
/**
* @module botbuilder-dialogs
*/
/**
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
const botbuilder_core_1 = require("botbuilder-core");
const choices_1 = require("../choices");
const dialog_1 = require("../dialog");
/**
* Controls the way that choices for a `ChoicePrompt` or yes/no options for a `ConfirmPrompt` are
* presented to a user.
*/
var ListStyle;
(function (ListStyle) {
/**
* Don't include any choices for prompt.
*/
ListStyle[ListStyle["none"] = 0] = "none";
/**
* Automatically select the appropriate style for the current channel.
*/
ListStyle[ListStyle["auto"] = 1] = "auto";
/**
* Add choices to prompt as an inline list.
*/
ListStyle[ListStyle["inline"] = 2] = "inline";
/**
* Add choices to prompt as a numbered list.
*/
ListStyle[ListStyle["list"] = 3] = "list";
/**
* Add choices to prompt as suggested actions.
*/
ListStyle[ListStyle["suggestedAction"] = 4] = "suggestedAction";
/**
* Add choices to prompt as a HeroCard with buttons.
*/
ListStyle[ListStyle["heroCard"] = 5] = "heroCard";
})(ListStyle = exports.ListStyle || (exports.ListStyle = {}));
/**
* Base class for all prompts.
*
* @param T Type of value being returned by the prompts recognizer function.
*/
class Prompt extends dialog_1.Dialog {
/**
* Creates a new Prompt instance.
*
* @param dialogId Unique ID of the prompt within its parent `DialogSet` or `ComponentDialog`.
* @param validator (Optional) custom validator used to provide additional validation and re-prompting logic for the prompt.
*/
constructor(dialogId, validator) {
super(dialogId);
this.validator = validator;
}
/**
* Called when a prompt dialog is pushed onto the dialog stack and is being activated.
*
* @param dc The [DialogContext](xref:botbuilder-dialogs.DialogContext) for the current
* turn of the conversation.
* @param options Optional. [PromptOptions](xref:botbuilder-dialogs.PromptOptions),
* additional information to pass to the prompt being started.
* @returns A `Promise` representing the asynchronous operation.
* @remarks
* If the task is successful, the result indicates whether the prompt is still
* active after the turn has been processed by the prompt.
*/
beginDialog(dc, options) {
return __awaiter(this, void 0, void 0, function* () {
// Ensure prompts have input hint set
const opt = Object.assign({}, options);
if (opt.prompt && typeof opt.prompt === 'object' && typeof opt.prompt.inputHint !== 'string') {
opt.prompt.inputHint = botbuilder_core_1.InputHints.ExpectingInput;
}
if (opt.retryPrompt && typeof opt.retryPrompt === 'object' && typeof opt.retryPrompt.inputHint !== 'string') {
opt.retryPrompt.inputHint = botbuilder_core_1.InputHints.ExpectingInput;
}
// Initialize prompt state
const state = dc.activeDialog.state;
state.options = opt;
state.state = {};
// Send initial prompt
yield this.onPrompt(dc.context, state.state, state.options, false);
return dialog_1.Dialog.EndOfTurn;
});
}
/**
* Called when a prompt dialog is the active dialog and the user replied with a new activity.
*
* @param dc The [DialogContext](xref:botbuilder-dialogs.DialogContext) for the current turn of conversation.
* @returns A `Promise` representing the asynchronous operation.
* @remarks
* If the task is successful, the result indicates whether the dialog is still
* active after the turn has been processed by the dialog.
* The prompt generally continues to receive the user's replies until it accepts the
* user's reply as valid input for the prompt.
*/
continueDialog(dc) {
return __awaiter(this, void 0, void 0, function* () {
// Don't do anything for non-message activities
if (dc.context.activity.type !== botbuilder_core_1.ActivityTypes.Message) {
return dialog_1.Dialog.EndOfTurn;
}
// Are we being continued after an interruption?
// - The stepCount will be 1 or more if we're running in the context of an AdaptiveDialog
// and we're coming back from an interruption.
const stepCount = dc.state.getValue('turn.stepCount');
if (typeof stepCount == 'number' && stepCount > 0) {
// re-prompt and then end
yield this.repromptDialog(dc.context, dc.activeDialog);
return dialog_1.Dialog.EndOfTurn;
}
// Perform base recognition
const state = dc.activeDialog.state;
const recognized = yield this.onRecognize(dc.context, state.state, state.options);
// Validate the return value
let isValid = false;
if (this.validator) {
if (state.state['attemptCount'] === undefined) {
state.state['attemptCount'] = 0;
}
isValid = yield this.validator({
context: dc.context,
recognized: recognized,
state: state.state,
options: state.options,
attemptCount: ++state.state['attemptCount'],
});
}
else if (recognized.succeeded) {
isValid = true;
}
// Return recognized value or re-prompt
if (isValid) {
return yield dc.endDialog(recognized.value);
}
else {
if (!dc.context.responded) {
yield this.onPrompt(dc.context, state.state, state.options, true);
}
return dialog_1.Dialog.EndOfTurn;
}
});
}
/**
* Called before an event is bubbled to its parent.
*
* @param dc The [DialogContext](xref:botbuilder-dialogs.DialogContext) for the current turn of conversation.
* @param event [DialogEvent](xref:botbuilder-dialogs.DialogEvent), the event being raised.
* @returns Whether the event is handled by the current dialog and further processing should stop.
* @remarks
* This is a good place to perform interception of an event as returning `true` will prevent
* any further bubbling of the event to the dialogs parents and will also prevent any child
* dialogs from performing their default processing.
*/
onPreBubbleEvent(dc, event) {
return __awaiter(this, void 0, void 0, function* () {
if (event.name == 'activityReceived' && dc.context.activity.type == botbuilder_core_1.ActivityTypes.Message) {
// Perform base recognition
const state = dc.activeDialog.state;
const recognized = yield this.onRecognize(dc.context, state.state, state.options);
return recognized.succeeded;
}
return false;
});
}
/**
* Called when a prompt dialog resumes being the active dialog on the dialog stack, such as
* when the previous active dialog on the stack completes.
*
* @param dc The DialogContext for the current turn of the conversation.
* @param _reason An enum indicating why the dialog resumed.
* @param _result Optional, value returned from the previous dialog on the stack.
* The type of the value returned is dependent on the previous dialog.
* @returns A Promise representing the asynchronous operation.
* @remarks
* If the task is successful, the result indicates whether the dialog is still
* active after the turn has been processed by the dialog.
*/
resumeDialog(dc, _reason, _result) {
return __awaiter(this, void 0, void 0, function* () {
// Prompts are typically leaf nodes on the stack but the dev is free to push other dialogs
// on top of the stack which will result in the prompt receiving an unexpected call to
// resumeDialog() when the pushed on dialog ends.
// To avoid the prompt prematurely ending we need to implement this method and
// simply re-prompt the user.
yield this.repromptDialog(dc.context, dc.activeDialog);
return dialog_1.Dialog.EndOfTurn;
});
}
/**
* Called when a prompt dialog has been requested to re-prompt the user for input.
*
* @param context [TurnContext](xref:botbuilder-core.TurnContext), context for the current
* turn of conversation with the user.
* @param instance [DialogInstance](xref:botbuilder-dialogs.DialogInstance), the instance
* of the dialog on the stack.
* @returns A `Promise` representing the asynchronous operation.
*/
repromptDialog(context, instance) {
return __awaiter(this, void 0, void 0, function* () {
const state = instance.state;
yield this.onPrompt(context, state.state, state.options, false);
});
}
/**
* Helper function to compose an output activity containing a set of choices.
*
* @param prompt The prompt to append the users choices to.
* @param channelId ID of the channel the prompt is being sent to.
* @param choices List of choices to append.
* @param style Configured style for the list of choices.
* @param options (Optional) options to configure the underlying ChoiceFactory call.
* @returns The composed activity ready to send to the user.
*/
appendChoices(prompt, channelId, choices, style, options) {
// Get base prompt text (if any)
let text = '';
if (typeof prompt === 'string') {
text = prompt;
}
else if (prompt && prompt.text) {
text = prompt.text;
}
// Create temporary msg
let msg;
switch (style) {
case ListStyle.inline:
msg = choices_1.ChoiceFactory.inline(choices, text, undefined, options);
break;
case ListStyle.list:
msg = choices_1.ChoiceFactory.list(choices, text, undefined, options);
break;
case ListStyle.suggestedAction:
msg = choices_1.ChoiceFactory.suggestedAction(choices, text);
break;
case ListStyle.heroCard:
msg = choices_1.ChoiceFactory.heroCard(choices, text);
break;
case ListStyle.none:
msg = botbuilder_core_1.MessageFactory.text(text);
break;
default:
msg = choices_1.ChoiceFactory.forChannel(channelId, choices, text, undefined, options);
break;
}
// Update prompt with text, actions and attachments
if (typeof prompt === 'object') {
// Clone the prompt Activity as to not modify the original prompt.
prompt = JSON.parse(JSON.stringify(prompt));
prompt.text = msg.text;
if (msg.suggestedActions &&
Array.isArray(msg.suggestedActions.actions) &&
msg.suggestedActions.actions.length > 0) {
prompt.suggestedActions = msg.suggestedActions;
}
if (msg.attachments) {
if (prompt.attachments) {
prompt.attachments = prompt.attachments.concat(msg.attachments);
}
else {
prompt.attachments = msg.attachments;
}
}
return prompt;
}
else {
msg.inputHint = botbuilder_core_1.InputHints.ExpectingInput;
return msg;
}
}
}
exports.Prompt = Prompt;
//# sourceMappingURL=prompt.js.map