@memori.ai/memori-api-client 0.1.0

package/src/speech.ts

@@ -0,0 +1,242 @@
+import * as speechSdk from 'microsoft-cognitiveservices-speech-sdk';
+
+const getTTSVoice = (lang: string, voiceType: 'MALE' | 'FEMALE'): string => {
+  let voice = '';
+  let voiceLang = lang.toUpperCase();
+  switch (voiceLang) {
+    case 'IT':
+      voice = `${
+        voiceType === 'MALE' ? 'it-IT-DiegoNeural' : 'it-IT-ElsaNeural'
+      }`;
+      break;
+    case 'DE':
+      voice = `${
+        voiceType === 'MALE' ? 'de-DE-ConradNeural' : 'de-DE-KatjaNeural'
+      }`;
+      break;
+    case 'EN':
+      voice = `${
+        voiceType === 'MALE' ? 'en-GB-RyanNeural' : 'en-GB-SoniaNeural'
+      }`;
+      break;
+    case 'ES':
+      voice = `${
+        voiceType === 'MALE' ? 'es-ES-AlvaroNeural' : 'es-ES-ElviraNeural'
+      }`;
+      break;
+    case 'FR':
+      voice = `${
+        voiceType === 'MALE' ? 'fr-FR-HenriNeural' : 'fr-FR-DeniseNeural'
+      }`;
+      break;
+    case 'PT':
+      voice = `${
+        voiceType === 'MALE' ? 'pt-PT-DuarteNeural' : 'pt-PT-RaquelNeural'
+      }`;
+      break;
+    default:
+      voice = `${
+        voiceType === 'MALE' ? 'it-IT-DiegoNeural' : 'it-IT-IsabellaNeural'
+      }`;
+      break;
+  }
+  return voice;
+};
+
+const getCultureCodeByLanguage = (lang: string): string => {
+  let voice = '';
+  let voiceLang = lang.toUpperCase();
+  switch (voiceLang) {
+    case 'IT':
+      voice = 'it-IT';
+      break;
+    case 'DE':
+      voice = 'de-DE';
+      break;
+    case 'EN':
+      voice = 'en-US';
+      break;
+    case 'ES':
+      voice = 'es-ES';
+      break;
+    case 'FR':
+      voice = 'fr-FR';
+      break;
+    case 'PT':
+      voice = 'pt-PT';
+      break;
+    default:
+      voice = 'it-IT';
+      break;
+  }
+  return voice;
+};
+
+const speech = (AZURE_COGNITIVE_SERVICES_TTS_KEY: string, DEBUG = false) => (
+  lang: string,
+  voiceType: 'FEMALE' | 'MALE'
+) => {
+  speechSdk.Recognizer.enableTelemetry(false);
+
+  let speechConfig: speechSdk.SpeechConfig = speechSdk.SpeechConfig.fromSubscription(
+    AZURE_COGNITIVE_SERVICES_TTS_KEY,
+    'eastus'
+  );
+  let speechSynthesizer: speechSdk.SpeechSynthesizer | null;
+  let audioDestination: speechSdk.SpeakerAudioDestination;
+
+  audioDestination = new speechSdk.SpeakerAudioDestination();
+  let audioOutputConfig = speechSdk.AudioConfig.fromSpeakerOutput(
+    audioDestination
+  );
+
+  // https://docs.microsoft.com/it-it/azure/cognitive-services/speech-service/language-support#text-to-speech
+  speechConfig.speechSynthesisVoiceName = getTTSVoice(lang, voiceType);
+
+  let langCultureCode = getCultureCodeByLanguage(lang);
+  speechConfig.speechSynthesisLanguage = langCultureCode;
+  speechConfig.speechRecognitionLanguage = langCultureCode;
+
+  /**
+   * speak
+   * @description Speaks the text using the speech synthesizer. (TTS)
+   * @param {string} text - The text to be synthesized.
+   * @param {func=} onAudioEnd - The callback to be invoked when the synthesized audio is finished.
+   */
+  const speak = (
+    text: string,
+    onAudioEnd?: (sender: speechSdk.IPlayer) => void
+  ) => {
+    stopSpeaking();
+
+    speechSynthesizer = new speechSdk.SpeechSynthesizer(
+      speechConfig,
+      audioOutputConfig
+    );
+
+    if (onAudioEnd) audioDestination.onAudioEnd = onAudioEnd;
+
+    speechSynthesizer.speakTextAsync(
+      text,
+      result => {
+        if (result) {
+          try {
+            if (DEBUG) console.log('speak result', result);
+            if (speechSynthesizer) {
+              speechSynthesizer.close();
+              speechSynthesizer = null;
+            }
+          } catch (e) {
+            console.error('speak error: ', e);
+            window.speechSynthesis.speak(new SpeechSynthesisUtterance(text));
+          }
+        } else if (DEBUG) {
+          console.log('speak no result', result);
+        }
+      },
+      error => {
+        console.error('speak:', error);
+        window.speechSynthesis.speak(new SpeechSynthesisUtterance(text));
+      }
+    );
+  };
+
+  /**
+   * isSpeaking
+   * @description Returns true if the synthesizer is speaking.
+   * @returns {boolean}
+   */
+  const isSpeaking = (): boolean => {
+    return !!speechSynthesizer;
+  };
+
+  /**
+   * stopSpeaking
+   * @description Stops the speech synthesizer if it is synthesizing.
+   */
+  const stopSpeaking = () => {
+    if (audioDestination) audioDestination.pause();
+    if (speechSynthesizer) {
+      speechSynthesizer.close();
+      speechSynthesizer = null;
+    }
+  };
+
+  const audioInputConfig = speechSdk.AudioConfig.fromDefaultMicrophoneInput();
+  let recognizer: speechSdk.SpeechRecognizer | null;
+
+  /**
+   * recognize
+   * @description Starts the speech recognition.
+   * @param {func=} onRecognized - Callback method invoked when the speech is recognized with the text.
+   */
+  const recognize = (onRecognized: (transcript: string) => void) => {
+    recognizer = new speechSdk.SpeechRecognizer(speechConfig, audioInputConfig);
+
+    recognizer.recognizing = (_s, e) => {
+      if (DEBUG) console.log(`RECOGNIZING: Text=${e.result.text}`);
+    };
+    recognizer.recognized = (_s, e) => {
+      if (e.result.reason === speechSdk.ResultReason.RecognizedSpeech) {
+        if (DEBUG) console.log(`RECOGNIZED: Text=${e.result.text}`);
+        onRecognized(e.result.text ?? '');
+      } else if (e.result.reason === speechSdk.ResultReason.NoMatch && DEBUG) {
+        console.log('NOMATCH: Speech could not be recognized.');
+      }
+    };
+    recognizer.canceled = (_s, e) => {
+      if (DEBUG) console.log(`CANCELED: Reason=${e.reason}`);
+
+      if (e.reason === speechSdk.CancellationReason.Error && DEBUG) {
+        console.log(`"CANCELED: ErrorCode=${e.errorCode}`);
+        console.log(`"CANCELED: ErrorDetails=${e.errorDetails}`);
+        console.log(
+          'CANCELED: Did you set the speech resource key and region values?'
+        );
+      }
+
+      stopRecognizing();
+    };
+
+    recognizer.sessionStopped = (_s, _e) => {
+      if (DEBUG) console.log('\n    Session stopped event.');
+      if (recognizer) recognizer.stopContinuousRecognitionAsync();
+    };
+    recognizer.startContinuousRecognitionAsync();
+  };
+
+  /**
+   * isRecognizing
+   * @description Returns true if the recognizer is recognizing.
+   * @returns {boolean}
+   */
+  const isRecognizing = (): boolean => {
+    return !!recognizer;
+  };
+
+  /**
+   * stopRecognizing
+   * @description Stops the speech recognizer if it is recognizing.
+   * @param {func=} onStop - (optional) The callback to be invoked when the speech recognition is stopped.
+   */
+  const stopRecognizing = (onStop?: () => void) => {
+    if (recognizer) {
+      recognizer.stopContinuousRecognitionAsync();
+      recognizer.close();
+      recognizer = null;
+
+      if (onStop) onStop();
+    }
+  };
+
+  return {
+    speak,
+    isSpeaking,
+    stopSpeaking,
+    recognize,
+    isRecognizing,
+    stopRecognizing,
+  };
+};
+
+export default speech;

package/src/types.ts

@@ -0,0 +1,440 @@
+export declare type Error = {
+  code: number;
+  message: string;
+};
+
+export declare type ResponseSpec = {
+  requestID: string;
+  requestDateTime: string;
+  resultCode: number;
+  resultMessage: string;
+};
+
+export declare type MemoriConfig = {
+  memoriConfigID: string;
+  useCase: string;
+  culture: string;
+  descriptions?: { [lang: string]: string };
+  dialogExamples?: { [lang: string]: string };
+  logoURL?: string;
+};
+
+export declare type Memori = {
+  memoriID: string;
+  name: string;
+  password?: string;
+  recoveryTokens?: string[];
+  newPassword?: string;
+  ownerUserID?: string;
+  ownerTenantName?: string;
+  memoriConfigurationID: string;
+  description: string;
+  engineMemoriID?: string;
+  isGiver?: boolean;
+  isReceiver?: boolean;
+  giverTag?: string;
+  giverPIN?: string;
+  privacyType: 'PUBLIC' | 'PRIVATE' | 'SECRET';
+  secretToken?: string;
+  minimumNumberOfRecoveryTokens?: number;
+  totalNumberOfRecoveryTokens?: number;
+  avatarURL?: string;
+  coverURL?: string;
+  needsPosition?: boolean;
+  voiceType: string;
+  culture?: string;
+  publishedInTheMetaverse?: boolean;
+  metaverseEnvironment?: string;
+  properties?: { [key: string]: string };
+  creationTimestamp?: string;
+  lastChangeTimestamp?: string;
+  integrations?: Integration[];
+  sentInvitations?: Invitation[];
+  receivedInvitations?: Invitation[];
+  categories?: string[];
+  ownerUserName?: string;
+};
+
+export declare type Venue = {
+  placeName: string;
+  latitude: number;
+  longitude: number;
+  uncertainty?: number;
+};
+
+export declare type User = {
+  tenant?: string;
+  userID?: string;
+  userName?: string;
+  password?: string;
+  newPassword?: string;
+  eMail?: string;
+  admin?: boolean;
+  superAdmin?: boolean;
+  verificationCode?: string;
+  flowID?: string;
+  newsletterSubscribed?: boolean;
+  maxMemori?: number;
+  canCreateMemori?: boolean;
+  canAccessAPI?: boolean;
+  canEditIntegrations?: boolean;
+  canEditDynamicIntents?: boolean;
+  canEditMemoriChaining?: boolean;
+  maxFreeSessions?: number;
+  creationTimestamp?: string;
+  lastChangeTimestamp?: string;
+};
+
+export declare type IntegrationResource = {
+  name: string;
+  url: string;
+};
+
+export declare type IntegrationType = 'GOOGLE' | 'ALEXA' | 'LANDING_EXPERIENCE';
+
+export declare type Integration = {
+  integrationID?: string;
+  memoriID?: string;
+  type: IntegrationType;
+  state?:
+    | 'NEW'
+    | 'PROCESSING'
+    | 'DONE'
+    | 'REMOVED'
+    | 'ERROR'
+    | 'WAITING_MANUAL_ACTION'
+    | 'DRAFT'
+    | 'NOT_VALIDATED'
+    | 'PUBLISHED';
+  publish?: boolean;
+  deviceEmails?: string[];
+  invocationText?: string;
+  jobID?: string;
+  customData?: string;
+  resources?: IntegrationResource[];
+  creationTimestamp?: string | Date;
+  lastChangeTimestamp?: string | Date;
+  dataResult?: { [key: string]: any };
+};
+
+export declare type PublicIntegrationListItem = {
+  integration: Integration;
+  memori: Memori;
+  memoriUser: User;
+  remoteMemoriId?: string;
+};
+
+export interface RcFile extends File {
+  readonly lastModifiedDate: string | Date;
+  uid: string;
+}
+
+export declare type UploadFileStatus =
+  | 'error'
+  | 'success'
+  | 'done'
+  | 'uploading'
+  | 'removed';
+
+export interface UploadFile<T = any> {
+  uid: string;
+  size?: number;
+  name: string;
+  fileName?: string;
+  lastModified?: number;
+  lastModifiedDate?: string | Date;
+  url?: string;
+  status?: UploadFileStatus;
+  percent?: number;
+  thumbUrl?: string;
+  originFileObj?: RcFile;
+  response?: T;
+  error?: any;
+  linkProps?: any;
+  type?: string;
+  xhr?: T;
+  preview?: string;
+}
+
+export declare type TenantConfig = {
+  name: string;
+  showNewUser: boolean;
+  requirePosition: boolean;
+  feedbackURL?: string;
+};
+
+export declare type Tenant = {
+  id: string;
+  theme: string;
+  config: TenantConfig;
+  disableRegistration?: boolean;
+  maxMemoriPerAdmin?: number;
+  maxMemoriPerUser?: number;
+  maxTotalMemori?: number;
+  maxAdmins?: number;
+  maxUsers?: number;
+  usersCanCreateMemori?: boolean;
+  usersCanAccessAPI?: boolean;
+  usersCanEditIntegrations?: boolean;
+  usersCanEditDynamicIntents?: boolean;
+  usersCanEditMemoriChaining?: boolean;
+  maxFreeSessions?: number;
+  maxFreeSessionsPerUser?: number;
+};
+
+export declare type OpenSession = {
+  memoriID: string;
+  password?: string;
+  recoveryTokens?: string[];
+  tag?: string;
+  pin?: string;
+  initialContextVars?: { [key: string]: string };
+};
+
+export declare type MemoriSession = {
+  sessionID: string;
+  currentState: DialogState;
+  stats?: Stats;
+};
+
+export declare type Medium = {
+  mediumID: string;
+  url?: string;
+  content?: string;
+  mimeType: string;
+  title?: string;
+  properties?: { [key: string]: string };
+  creationTimestamp?: string;
+  creationName?: string;
+  lastChangeTimestamp?: string;
+  lastChangeName?: string;
+};
+
+export declare type Stats = {
+  totalReceivers: number;
+  receiversWithMemories: number;
+  totalMemories: number;
+  publicMemories: number;
+  memoriesWithMedia: number;
+  totalQuestions: number;
+  publicQuestions: number;
+  questionsWithMoreThanOneAnswer: number;
+  totalStories: number;
+  publicStories: number;
+  storiesWithDate: number;
+  storiesWithPlace: number;
+  storiesWithDateAndPlace: number;
+  unansweredQuestions: number;
+  successfulCorrelations: number;
+  failedCorrelations: number;
+};
+
+export declare type GamificationLevel = {
+  points: number;
+  badge: string;
+  pointsForCurrentBadge: number;
+  nextBadge: {
+    points: number;
+    badge: string;
+  };
+};
+
+export declare type EventLog = {
+  eventLogID: string;
+  timestamp: string;
+  eventType: string;
+  memoriID: string;
+  userAgent?: string;
+  ipAddress?: string;
+  memoryID?: string;
+  intentID?: string;
+  enteredText?: string;
+  receiverTag?: string;
+};
+
+export declare type UserLog = {
+  timestamp: string;
+  count: number;
+};
+
+export declare type UsersLog = {
+  timestamp: string;
+  countUsers: number;
+  countRecurrentUsers: number;
+};
+
+export declare type TranslatedHint = {
+  text: string;
+  originalText: string;
+};
+
+export declare type DialogState = {
+  state: string;
+  stateName: string;
+  previousState: string;
+  confidence?: number;
+  emission?: string;
+  acceptsTimeout?: boolean;
+  acceptsAbort?: boolean;
+  acceptsMedia?: boolean;
+  acceptsDate?: boolean;
+  acceptsPlace?: boolean;
+  acceptsTag?: boolean;
+  hints?: string[];
+  translatedHints?: TranslatedHint[];
+  currentTag?: string;
+  currentDate?: string;
+  currentPlaceName?: string;
+  currentLatitude?: number;
+  currentLongitude?: number;
+  currentUncertaintyKm?: number;
+  giverID?: string;
+  currentReceiverID?: string;
+  currentMemoryID?: string;
+  media?: Medium[];
+  knownTags?: { [key: string]: string };
+  contextVars?: { [key: string]: string };
+};
+
+export declare type Person = {
+  personID?: string;
+  personType: 'Giver' | 'Receiver';
+  name?: string;
+  information?: string;
+  pin: string;
+  tag: string;
+  creationTimestamp?: string;
+  creationName?: string;
+  lastChangeTimestamp?: string;
+  lastChangeName?: string;
+};
+
+export declare type PersonificationProfile = {
+  tag?: string;
+  pin?: string;
+  name?: string;
+  sessionID: string;
+};
+
+export declare type Invitation = {
+  invitationID?: string;
+  memoriID: string;
+  isInviter?: boolean;
+  isInvitee?: boolean;
+  text?: string;
+  destinationEMail: string;
+  destinationName: string;
+  tag: string;
+  pin: string;
+  type: string;
+  state?: 'PENDING' | 'ACCEPTED' | 'REJECTED';
+  creationTimestamp?: string;
+  lastChangeTimestamp?: string;
+};
+
+export declare type LocalizationKeyContent = {
+  key: string;
+  value: string;
+};
+
+export declare type LocalizationKey = LocalizationKeyContent & {
+  creationTimestamp?: string;
+  creationName?: string;
+  lastChangeTimestamp?: string;
+  lastChangeName?: string;
+};
+
+export declare type Asset = {
+  assetID: string;
+  assetURL: string;
+  mimeType: string;
+  memoriID: string;
+  originalFileName?: string;
+  title?: string;
+  engineMemoryID?: string;
+  creationTimestamp: string;
+  lastChangeTimestamp: string;
+};
+
+export declare type SearchQuery = {
+  text: string;
+  searchType?: 'Literal' | 'Semantic';
+  date?: string;
+  dateUncertaintyDays?: number;
+  placeName?: string;
+  placeLatitude?: number;
+  placeLongitude?: number;
+  placeUncertaintyKm?: number;
+  tag?: string;
+  ignoreLastRead?: boolean;
+  excludedMemoryIDs?: string[];
+  numberOfResults?: number;
+};
+
+export declare type SearchMatches = {
+  confidence: number;
+  confidenceLevel?: 'LOW' | 'MEDIUM' | 'HIGH';
+  memory: Memory;
+};
+
+export declare type Answer = {
+  text: string;
+  preformatted?: boolean;
+  creationTimestamp?: string;
+  creationName?: string;
+  lastChangeTimestamp?: string;
+  lastChangeName?: string;
+};
+
+export declare type Memory = {
+  memoryID: string;
+  memoryType: string;
+  lastRead?: string;
+  readOccurrencies?: number;
+  receiverID?: string;
+  receiverTag?: string;
+  receiverName?: string;
+  media?: Medium[];
+  text?: string;
+  textVariants?: string[];
+  answers?: Answer[];
+  title?: string;
+  titleVariants?: string[];
+  date?: string;
+  dateUncertaintyDays?: number;
+  placeName?: string;
+  placeLatitude?: number;
+  placeLongitude?: number;
+  placeUncertaintyKm?: number;
+  preformatted?: boolean;
+  conclusive?: boolean;
+  help?: boolean;
+  notPickable?: boolean;
+  contextVarsToSet?: { [variable: string]: string };
+  contextVarsToMatch?: { [variable: string]: string };
+  creationTimestamp?: string;
+  creationName?: string;
+  lastChangeTimestamp?: string;
+  lastChangeName?: string;
+};
+
+export declare type UnansweredQuestion = {
+  unansweredQuestionID?: string;
+  text: string;
+  occurrencies: number;
+  receiverID?: string;
+  receiverTag?: string;
+  receiverName?: string;
+  creationTimestamp?: string;
+  creationName?: string;
+  lastChangeTimestamp?: string;
+  lastChangeName?: string;
+  candidateAnswers?: SearchMatches[];
+};
+
+export declare type Message = {
+  text: string;
+  fromUser?: boolean;
+  media?: Medium[];
+  initial?: boolean;
+};