@memori.ai/memori-react 6.8.1 → 6.8.4

package/src/helpers/message.ts

@@ -0,0 +1,148 @@
+import { marked } from 'marked';
+import DOMPurify from 'dompurify';
+import { MAX_MSG_CHARS, MAX_MSG_WORDS } from './constants';
+import { cleanUrl } from './utils';
+import markedLinkifyIt from 'marked-linkify-it';
+import markedKatex from 'marked-katex-extension';
+import markedExtendedTables from './markedExtendedTables';
+
+// Always configure marked with necessary extensions
+marked.use({
+  async: false,
+  gfm: true,
+  pedantic: false,
+  renderer: {
+    link: ({
+      href,
+      title,
+      text,
+    }: {
+      href: string | null;
+      title?: string | null;
+      text: string;
+    }) => {
+      const cleanHref = href ? cleanUrl(href) : null;
+
+      if (cleanHref === null) {
+        return text;
+      }
+      href = cleanHref;
+      let out = '<a href="' + href + '"';
+      if (title) {
+        out += ' title="' + title + '"';
+      }
+      out += ' target="_blank" rel="noopener noreferrer">' + text + '</a>';
+      return out;
+    },
+  },
+});
+
+marked.use(markedLinkifyIt());
+marked.use(markedExtendedTables());
+
+export const needsTruncation = (message: string) => {
+  return (
+    message.length > MAX_MSG_CHARS || message.split(' ').length > MAX_MSG_WORDS
+  );
+};
+
+export const truncateMessage = (message: string) => {
+  let truncatedMessage = message;
+  if (message.length > MAX_MSG_CHARS) {
+    truncatedMessage = `${message.slice(0, MAX_MSG_CHARS)}\n<br />...`;
+  }
+  if (truncatedMessage.split(' ').length > MAX_MSG_WORDS) {
+    truncatedMessage = truncatedMessage
+      .split(' ')
+      .slice(0, MAX_MSG_WORDS)
+      .join(' ');
+  }
+  return truncatedMessage;
+};
+
+export const renderMsg = (
+  text: string,
+  useMathFormatting = false,
+  reasoningText = 'Reasoning...',
+  showReasoning: boolean
+): {
+  text: string;
+} => {
+  try {
+    // Preprocessing del testo per gestire i delimitatori LaTeX
+    let preprocessedText = text
+      .trim()
+      .replaceAll(
+        /\[([^\]]+)\]\(([^\)]+)\)/g,
+        '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>'
+      )
+      .replaceAll(
+        /<think.*?>(.*?)<\/think>/gs,
+        showReasoning
+          ? `<details class="memori-think"><summary>${reasoningText}</summary>$1</details>`
+          : ''
+      )
+      // Remove document_attachment tags from text - they will be handled as media
+      .replaceAll(
+        /<document_attachment filename="([^"]+)" type="([^"]+)">([\s\S]*?)<\/document_attachment>/g,
+        ''
+      )
+      .replaceAll(/<output\s+class\s*=\s*["\']memori-artifact["\'][^>]*data-mimetype\s*=\s*["\']([^"']+)["\'][^>]*>([\s\S]*?)(?:<\/output>|$)/gi, '')
+      .replaceAll(/```markdown([^```]+)```/g, '$1')
+      .replaceAll('($', '( $')
+      .replaceAll(':$', ': $')
+      .replaceAll('\frac', '\\frac')
+      .replaceAll('\beta', '\\beta')
+      .replaceAll('cdot', '\\cdot');
+
+    // Correzione dei delimitatori LaTeX inconsistenti
+    if (useMathFormatting) {
+      // Abilita il supporto per KaTeX
+      marked.use(markedKatex({}));
+
+      // Normalizza tutti i delimitatori LaTeX per equazioni su linea separata
+      // Da \\[ ... \\] o \\[ ... ] a $$ ... $$
+      preprocessedText = preprocessedText.replace(
+        /\\+\[(.*?)\\*\]/gs,
+        (_, content) => {
+          return `$$${content}$$`;
+        }
+      );
+
+      // Gestione dei delimitatori [ ... ] che dovrebbero essere equazioni
+      preprocessedText = preprocessedText.replace(
+        /\[([^[\]]+?)\]/g,
+        (match, content) => {
+          // Verifica se sembra una formula matematica
+          if (
+            /[\\+a-z0-9_{}^=\-\+\*\/]+/i.test(content) &&
+            !match.startsWith('[http') &&
+            !match.includes('](')
+          ) {
+            return `$$${content}$$`;
+          }
+          return match; // Mantieni invariati i link e altre strutture
+        }
+      );
+    }
+
+    // Ora procedi con il parsing markdown
+    let parsedText = marked.parse(preprocessedText).toString().trim();
+
+    // Sanitize HTML
+    parsedText = DOMPurify.sanitize(parsedText, {
+      ADD_ATTR: ['target'],
+    });
+
+    // Clean up final text
+    const finalText = parsedText
+      .replace(/(<br>)+/g, '<br>')
+      .replace(/<p><\/p>/g, '<br>')
+      .replace(/<p><br><\/p>/g, '<br>');
+
+    return { text: finalText };
+  } catch (e) {
+    console.error('Error rendering message:', e);
+    return { text };
+  }
+};

package/src/helpers/sanitizer.ts

@@ -0,0 +1,17 @@
+// tts/TextSanitizer.ts
+
+import { escapeHTML, stripEmojis, stripHTML, stripMarkdown, stripOutputTags, stripReasoningTags } from "./utils";
+
+
+
+/**
+ * Sanitizza completamente il testo per la sintesi vocale
+ * @param text Testo da sanitizzare
+ */
+export function sanitizeText(text: string): string {
+  return escapeHTML(
+    stripMarkdown(
+      stripEmojis(stripHTML(stripReasoningTags(stripOutputTags(text))))
+    )
+  );
+}

package/src/helpers/statistics.ts

@@ -1,158 +1,4 @@
-import {
-  Stats,
-  GamificationLevel,
-  EventLog,
-  UsersLog,
-  Memori,
-  Invitation,
-} from '@memori.ai/memori-api-client/dist/types';
-import memoriApiClient from '@memori.ai/memori-api-client';
-
-const { deleteSession, getStatistics, initSession } = memoriApiClient();
-
-const conversionTable: { [key: string]: number } = {
-  totalReceivers: 0.2,
-  receiversWithMemories: 0.4,
-  totalMemories: 0.2,
-  publicMemories: 0.4,
-  memoriesWithMedia: 0.4,
-  totalQuestions: 0.2,
-  publicQuestions: 0.3,
-  questionsWithMoreThanOneAnswer: 0.4,
-  totalStories: 0.2,
-  publicStories: 0.4,
-  storiesWithDate: 0.5,
-  storiesWithPlace: 0.4,
-  storiesWithDateAndPlace: 0.6,
-  unansweredQuestions: 0,
-  successfulCorrelations: 0,
-  failedCorrelations: 0,
-};
-
-export const BADGES_MAP: Map<number, string> = new Map([
-  [0, '🆕'],
-  [10, '🐹'],
-  [20, '🐇'],
-  [30, '🐰'],
-  [40, '💡'],
-  [50, '🏆'],
-  [60, '🏅'],
-  [70, '🥉'],
-  [80, '🥈'],
-  [90, '🥇'],
-  [100, '🔥'],
-  [110, '🎓'],
-  [120, '🤖'],
-  [130, '👾'],
-  [150, '🌍'],
-  [180, '💜'],
-  [200, '💙'],
-  [250, '🧡'],
-  [300, '💚'],
-  [350, '💛'],
-  [400, '💖'],
-  [450, '💝'],
-  [500, '🖤'],
-  [550, '❤️'],
-  [600, '🧠'],
-]);
-
-export const getBadge = (points: number): string => {
-  const unlockedBadges = Array.from(BADGES_MAP.keys()).filter(
-    (k: number) => k <= points
-  );
-
-  if (unlockedBadges.length > 0) {
-    const lastBadge = unlockedBadges[unlockedBadges.length - 1];
-    return BADGES_MAP.get(lastBadge) as string;
-  }
-
-  return '';
-};
-
-export const getNextBadge = (
-  badge: string
-): { points: number; badge: string } | undefined => {
-  if (badge === '🆕') {
-    return { points: 10, badge: '🐹' };
-  }
-  let nextBadgePoints;
-  let nextBadge;
-
-  let currentSeen = false;
-  for (const [key, value] of BADGES_MAP) {
-    if (currentSeen) {
-      nextBadgePoints = key;
-      nextBadge = value;
-      break;
-    }
-
-    if (value === badge) {
-      currentSeen = true;
-    }
-  }
-
-  return nextBadge && nextBadgePoints
-    ? {
-        points: nextBadgePoints,
-        badge: nextBadge,
-      }
-    : undefined;
-};
-
-export const getPointsForBadge = (badge: string): number => {
-  let points = 0;
-
-  for (const [key, value] of BADGES_MAP) {
-    if (value === badge) {
-      points = key;
-      break;
-    }
-  }
-
-  return points;
-};
-
-export const getPointsFromStats = (stats: Stats): number => {
-  let points = 0;
-  Object.entries(stats).forEach(stat => {
-    if (stat[0] in conversionTable) {
-      points += stat[1] * conversionTable[stat[0]];
-    }
-  });
-  return Math.trunc(points);
-};
-
-export const getGamificationLevel = (points: number): GamificationLevel => {
-  const roundedPoints = Math.round(points);
-  const badge = getBadge(roundedPoints);
-  const pointsForCurrentBadge = getPointsForBadge(badge);
-  const nextBadge = getNextBadge(badge);
-
-  return {
-    points: roundedPoints,
-    badge,
-    pointsForCurrentBadge,
-    nextBadge,
-  };
-};
-
-export const getGamificationLevelByStats = (
-  stats: Stats
-): GamificationLevel => {
-  const floatPoints = getPointsFromStats(stats);
-  const points = Math.round(floatPoints);
-  const badge = getBadge(points);
-  const pointsForCurrentBadge = getPointsForBadge(badge);
-  const nextBadge = getNextBadge(badge);
-
-  return {
-    points,
-    badge,
-    pointsForCurrentBadge,
-    nextBadge,
-  };
-};
+import { EventLog, UsersLog } from '@memori.ai/memori-api-client/dist/types';
 
 const groupBy = <T>(array: T[], predicate: (v: T) => string) =>
   array.reduce((acc, value) => {
@@ -210,43 +56,3 @@ export const eventLogGroupUsersByDate = (eventLogs: EventLog[]): UsersLog[] => {
   });
   return userLogs;
 };
-
-export const getMemoriUnansQuestions = async (memori: Memori) => {
-  if (memori.privacyType === 'SECRET' || !memori.isGiver) return 0;
-  try {
-    if (!memori.giverTag && !!memori.receivedInvitations?.length) {
-      let giverInvitation = memori.receivedInvitations.find(
-        (i: Invitation) => i.type === 'GIVER' && i.state === 'ACCEPTED'
-      );
-
-      if (giverInvitation) {
-        memori.giverTag = giverInvitation.tag;
-        memori.giverPIN = giverInvitation.pin;
-      }
-    }
-
-    const { sessionID, currentState, ...response } = await initSession({
-      memoriID: memori.engineMemoriID ?? '',
-      password: memori.secretToken,
-      tag: memori.giverTag,
-      pin: memori.giverPIN,
-    });
-
-    if (response.resultCode !== 0 || !sessionID) {
-      return 0;
-    }
-
-    const { statistics, ...resp } = await getStatistics(sessionID);
-
-    await deleteSession(sessionID);
-
-    if (statistics && resp.resultCode === 0) {
-      return statistics.unansweredQuestions;
-    }
-
-    return 0;
-  } catch (e) {
-    console.log(e);
-    return 0;
-  }
-};