@telia-ace/widget-conversation 1.0.29-next.4 → 1.0.29-next.5

package/README.md

@@ -394,3 +394,32 @@ component.actions.watch('conversation.action', (input, next) => {
     }
 });
 ```
+
+## Completing a conversation (handover)
+
+When you are handing over the conversation to another provider, the current provider is disabled until the child provider has completed. To hand it over to the previous provider you should use the `complete()` method on the `ConversationProvider` object.
+
+Example:
+
+```ts
+if (actionKey === 'email-confirmation-submit') {
+    conversation.complete();
+}
+```
+
+This will complete the current provider and return to the one that started the now closed provider.
+
+## Rehydrating the conversation
+
+The conversation may be stored in a session to allow it to remain when reloading the page.
+This behavior is disabled by default but can be turned on by adding the `rehydrate` property to the `ConversationComponent` like this:
+
+```
+"components": {
+    "type": "conversation",
+    "properties": {
+        "rehydrate": true
+    }
+}
+
+```

package/dist/agent.d.ts

@@ -3,15 +3,19 @@ import { ConversationEntry } from './conversation-controller';
 import { ConversationProvider } from './conversation-provider';
 import { ConversationMessageSettings, ConverstationMessageItem } from './types';
 export declare type AgentSettings = {
+    id?: string;
     name?: string;
     avatar?: string | Symbol;
 };
 export declare class Agent {
     private provider;
+    id: string;
     name?: string;
     avatar?: string | Symbol;
     constructor(provider: ConversationProvider, settings: AgentSettings);
-    print: (settings: string | ConversationMessageSettings | ConverstationMessageItem<any> | ConverstationMessageItem<any>[]) => ConversationEntry | undefined;
+    print: (settings: string | ConversationMessageSettings | ConverstationMessageItem<any> | ConverstationMessageItem<any>[], options?: {
+        key?: string;
+    }) => ConversationEntry | undefined;
     typing: () => (() => void) | undefined;
     update(settings: AgentSettings): void;
 }

package/dist/components/conversation/plugin.d.ts

@@ -29,9 +29,11 @@ export declare type ConversationComponentProperties = {
     inputDisabled: boolean;
     inputHidden: boolean;
     inputMultiline: boolean;
+    rehydrate?: boolean;
     userLabel: string;
     avatarSize: string;
     typingActors: any[];
+    conversationControllerId?: string;
     sendButtonLabel: string;
     secondaryAction?: {
         icon?: string;

package/dist/conversation-controller.d.ts

@@ -1,4 +1,5 @@
 import { Container, EventListener, EventManager } from '@webprovisions/platform';
+import { AgentSettings } from './agent';
 import { ConversationProvider } from './conversation-provider';
 import { ConversationMessageContent, ConversationMessageSender, ConversationMessageSettings, ConversationMessageUpdateSettings, ConverstationMessageItem, NormalizedMessageSettings } from './types';
 import { User } from './user';
@@ -8,6 +9,9 @@ export declare type ValidateHandler = (formValues: {
 export declare type SubmitHandler = (formValues: {
     [key: string]: any;
 }) => Promise<any>;
+export declare type ConversationOptions = {
+    silent: boolean;
+};
 export declare type Print = (content: string | ConversationMessageContent) => ConversationEntry;
 export declare type FormHandlers = {
     [key: string]: FormHandler;
@@ -37,7 +41,9 @@ export declare type ConversationMessage = {
     type: ConversationMessageType;
 };
 export declare type EntryWriter = (content: ConversationMessageUpdateSettings | null) => void;
-export declare const getNormalizedMessageSettings: (settings: string | ConversationMessageSettings | ConverstationMessageItem<any> | ConverstationMessageItem<any>[]) => NormalizedMessageSettings;
+export declare const getNormalizedMessageSettings: (settings: string | ConversationMessageSettings | ConverstationMessageItem<any> | ConverstationMessageItem<any>[], options?: {
+    key?: string | undefined;
+} | undefined) => NormalizedMessageSettings;
 /**
  * Manages the stream of messages inside a `ConversationComponent` and provides external read-write
  * access to it as well as exposing emitted actions.
@@ -53,21 +59,40 @@ export declare class ConversationController {
     events: EventManager;
     providers: string[];
     active: boolean;
-    private registeredProviders;
+    queuedProviders: string[];
+    registeredProviders: ConversationProvider[];
     private loaders;
     private componentMounted;
+    private store;
     messages: ConversationMessage[];
     private typingActors;
-    constructor(container: Container, id: string);
+    constructor(container: Container, id: string, options: {
+        rehydrate: boolean;
+    });
+    setInitialStorage(data: {
+        agents: AgentSettings[];
+    }): void;
     setProviders(providers: string[]): void;
     createProvider(name: string): ConversationProvider;
     providerIndex(name: string): number;
+    getAgentById(id?: string): {
+        id: string;
+        name: string;
+        avatar?: string | undefined;
+        providerName: string;
+    } | undefined;
     dispose(): void;
     onDispose(fn: EventListener): import("@webprovisions/platform").EventSubscriptionCancellation;
     onStarted(fn: EventListener): import("@webprovisions/platform").EventSubscriptionCancellation;
+    onMessageCreated(fn: EventListener): import("@webprovisions/platform").EventSubscriptionCancellation;
+    isRehydrated(): Promise<boolean>;
     disposeProvider(target: ConversationProvider): void;
     onProvidersChange(fn: EventListener): import("@webprovisions/platform").EventSubscriptionCancellation;
     setComponentMountedState(mounted: boolean): void;
+    setProviderOptions(providerName: string, options: ConversationOptions): void;
+    changeProvider(providerName: string): void;
+    queueProviders(providers: string[]): void;
+    onCompleteProvider(): void;
     getComponentMountedState(): boolean;
     onUnreadMessage(fn: EventListener): import("@webprovisions/platform").EventSubscriptionCancellation;
     createEntry(key: string, content: ConversationMessageContent, type: ConversationMessageType, sender?: ConversationMessageSender, timestamp?: number | null): ConversationEntry;

package/dist/conversation-platform.d.ts

@@ -23,7 +23,10 @@ export declare class ConversationPlatform {
     private container;
     private components;
     events: EventManager;
-    private controllers;
+    controllers: {
+        conversation: ConversationController;
+        component: ComponentNodeController;
+    }[];
     private providers;
     private disposeProviders;
     private subscriptions;
@@ -37,7 +40,9 @@ export declare class ConversationPlatform {
     static getInstance(container: Container, key?: string): Promise<ConversationPlatform>;
     navigateToConversationIfActive(id: string): Promise<void>;
     setConversationEndedBehavior(behavior: ConversationEndedBehavior): Promise<void>;
-    createController(id: string): ConversationController;
+    createController(id: string, options: {
+        rehydrate: boolean;
+    }): Promise<ConversationController>;
     registerProvider(name: string, handler: ConversationHandler): void;
     registerController(conversation: ConversationController, component: ComponentNodeController): boolean;
     private writeToComponents;

package/dist/conversation-provider.d.ts

@@ -1,12 +1,13 @@
 import { Container, EventListener, EventSubscriptionCancellation } from '@webprovisions/platform';
 import { Agent, AgentSettings } from './agent';
-import { CancelLoaderDelegate, ConversationController, ConversationEntry, ConversationMessageType } from './conversation-controller';
+import { CancelLoaderDelegate, ConversationController, ConversationEntry, ConversationMessageType, ConversationOptions } from './conversation-controller';
 import { ConversationMessageContent, ConversationMessageSender, ConversationMessageSettings } from './types';
 export declare class ConversationProvider {
     name: string;
     private container;
     controller: ConversationController | null;
     private subscriptions;
+    options: ConversationOptions;
     user: any;
     private constructor();
     static create(name: string, container: Container, controller: ConversationController): ConversationProvider;
@@ -16,6 +17,9 @@ export declare class ConversationProvider {
     loading(): CancelLoaderDelegate;
     createEntry(key: string, content: ConversationMessageContent, type: ConversationMessageType, sender?: ConversationMessageSender, timestamp?: number | null): ConversationEntry | undefined;
     dispose(): void;
+    isRehydrated(): Promise<boolean>;
+    complete(): void;
+    setOptions(options?: ConversationOptions): void;
     onUnreadMessage(fn: EventListener): EventSubscriptionCancellation | void;
     onMounted(fn: EventListener): EventSubscriptionCancellation | void;
 }