@memori.ai/memori-react 8.45.2 → 8.45.5

package/src/helpers/constants.ts

@@ -1,268 +0,0 @@
-export const chatLanguages = [
-  { value: 'AR', label: 'العربية' },           // Arabic
-  { value: 'BG', label: 'български' },         // Bulgarian
-  { value: 'CS', label: 'Čeština / český jazyk' }, // Czech
-  { value: 'DA', label: 'Dansk' },             // Danish
-  { value: 'DE', label: 'Deutsch' },           // German
-  { value: 'EL', label: 'Ελληνικά' },          // Greek
-  { value: 'EN', label: 'English' },           // English
-  { value: 'ES', label: 'Español' },           // Spanish
-  { value: 'ET', label: 'Eesti keel' },        // Estonian
-  { value: 'FI', label: 'Suomi' },             // Finnish
-  { value: 'FR', label: 'Français' },          // French
-  { value: 'HR', label: 'Hrvatski' },          // Croatian
-  { value: 'HU', label: 'Magyar' },            // Hungarian
-  { value: 'IT', label: 'Italiano' },          // Italian
-  { value: 'JA', label: '日本語' },             // Japanese
-  { value: 'LT', label: 'Lietuvių kalba' },    // Lithuanian
-  { value: 'LV', label: 'Latvian' },           // Latvian / Lettonian
-  { value: 'NL', label: 'Nederlands' },        // Dutch
-  { value: 'PL', label: 'Polski' },            // Polish
-  { value: 'PT', label: 'Português' },         // Portuguese
-  { value: 'RO', label: 'Română' },            // Romanian
-  { value: 'RU', label: 'Русский' },           // Russian
-  { value: 'SK', label: 'Slovenčina' },        // Slovak
-  { value: 'SL', label: 'Slovenščina' },       // Slovenian
-  { value: 'SV', label: 'Svenska' },           // Swedish
-  { value: 'UK', label: 'Українська' },        // Ukrainian
-  { value: 'ZH', label: '中文' },              // Chinese
-];
-
-export const popularLanguageCodes = ['IT', 'EN'];
-
-export const getGroupedChatLanguages = () => {
-  const popular = chatLanguages.filter(lang =>
-    popularLanguageCodes.includes(lang.value)
-  );
-  const all = chatLanguages.filter(lang => !popularLanguageCodes.includes(lang.value));
-  return {
-    popular,
-    all,
-  };
-};
-
-export const uiLanguages = ['en', 'it', 'fr', 'es', 'de'];
-
-/** Extensions uploaded as original Office binaries (no text extraction) */
-export const officeNativeExtensions = [] as const;
-
-/** Extensions read as UTF-8 in the browser, without calling the conversion API */
-export const localTextExtensions = [
-  '.txt',
-  '.csv',
-  '.tsv',
-  '.html',
-  '.xhtml',
-  '.htm',
-  '.xml',
-  '.json',
-  '.md',
-  '.log',
-  '.yml',
-  '.yaml',
-] as const;
-
-export const documentConversionExtensions = [
-  '.pdf',
-  '.docx',
-  '.docm',
-  '.dotx',
-  '.xlsx',
-  '.xlsm',
-  '.xls',
-  '.xltx',
-  '.ods',
-  '.pptx',
-  '.pptm',
-  '.potx',
-] as const;
-
-export const allowedMediaTypes = [
-  'image/jpeg',
-  'image/png',
-  'image/jpg',
-  'image/gif',
-  'application/msword',
-  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-  'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
-  'application/vnd.ms-excel',
-  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-  'application/pdf',
-  'video/mp4',
-  'video/avi',
-  'audio/mpeg3',
-  'audio/wav',
-  'audio/mpeg',
-  'video/mpeg',
-  'model/gltf-binary',
-];
-
-/** Short badge labels for Office document cards */
-export const officeMimeShortLabels: Record<string, string> = {
-  'application/msword': 'Word',
-  'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'Word',
-  'application/vnd.openxmlformats-officedocument.wordprocessingml.template': 'Word',
-  'application/vnd.ms-excel': 'Excel',
-  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'Excel',
-  'application/vnd.openxmlformats-officedocument.spreadsheetml.template': 'Excel',
-  'application/vnd.openxmlformats-officedocument.presentationml.template': 'PPT',
-};
-
-export const officeExtensionShortLabels: Record<string, string> = {
-  DOC: 'Word',
-  DOCX: 'Word',
-  DOTX: 'Word',
-  XLS: 'Excel',
-  XLSX: 'Excel',
-  XLTX: 'Excel',
-  POTX: 'PPT',
-};
-
-export const anonTag = '👤';
-
-export const prismSyntaxLangs = [
-  {
-    name: 'javascript/jsx',
-    lang: 'jsx',
-    mimeType: 'text/javascript',
-    monacoLang: 'javascript',
-    executable: true,
-  },
-  {
-    name: 'typescript/tsx',
-    lang: 'tsx',
-    mimeType: 'text/ecmascript',
-    monacoLang: 'typescript',
-    executable: true,
-  },
-  {
-    name: 'json',
-    lang: 'json',
-    mimeType: 'application/json',
-    monacoLang: 'json',
-    executable: true,
-  },
-  {
-    name: 'css',
-    lang: 'scss',
-    mimeType: 'text/css',
-    monacoLang: 'css',
-    executable: true,
-  },
-  {
-    name: 'html/xml',
-    lang: 'tsx',
-    mimeType: 'application/xml',
-    monacoLang: 'xml',
-  },
-  {
-    name: 'bash',
-    lang: 'bash',
-    mimeType: 'application/x-sh',
-    monacoLang: 'shell',
-  },
-  {
-    name: 'python',
-    lang: 'python',
-    mimeType: 'text/x-python',
-    monacoLang: 'python',
-  },
-  {
-    name: 'cpp/csharp',
-    lang: 'cpp',
-    mimeType: 'text/x-c++src',
-    monacoLang: 'cpp',
-  },
-  {
-    name: 'php',
-    lang: 'php',
-    mimeType: 'application/x-php',
-    monacoLang: 'php',
-  },
-  {
-    name: 'ruby',
-    lang: 'ruby',
-    mimeType: 'text/x-ruby',
-    monacoLang: 'ruby',
-  },
-  {
-    name: 'sql',
-    lang: 'sql',
-    mimeType: 'text/x-sql',
-    monacoLang: 'sql',
-  },
-];
-
-export const boardOfExpertsLoadingSentences: {
-  [lang: string]: {
-    /**
-     * Sentence to show
-     */
-    text: string;
-    /**
-     * Seconds to wait after the sentence is completed
-     */
-    delayAfter: number;
-  }[];
-} = {
-  it: [
-    {
-      text: '',
-      delayAfter: 10,
-    },
-    {
-      text: "Cerco l'esperto più adatto",
-      delayAfter: 5,
-    },
-    {
-      text: "Contatto l'esperto",
-      delayAfter: 3,
-    },
-    {
-      text: "Spiego all'esperto la domanda",
-      delayAfter: 2,
-    },
-    {
-      text: "L'esperto sta preparando una risposta",
-      delayAfter: 6,
-    },
-    {
-      text: 'Genero una risposta adatta',
-      delayAfter: 3,
-    },
-  ],
-  en: [
-    {
-      text: '',
-      delayAfter: 10,
-    },
-    {
-      text: "I'm looking for the most suitable expert",
-      delayAfter: 5,
-    },
-    {
-      text: "I'm contacting the expert",
-      delayAfter: 3,
-    },
-    {
-      text: "I'm explaining the question to the expert",
-      delayAfter: 2,
-    },
-    {
-      text: 'The expert is preparing an answer',
-      delayAfter: 6,
-    },
-    {
-      text: 'I am generating a suitable answer',
-      delayAfter: 3,
-    },
-  ],
-};
-
-export const MAX_MSG_CHARS = 4000;
-export const MAX_MSG_WORDS = 300;
-
-export const maxDocumentsPerMessage = 10;
-export const maxDocumentContentLength = 300000;
-export const pasteAsCardLineThreshold = 100;
-export const pasteAsCardCharThreshold = 4200;

package/src/helpers/convertDocument.test.ts

@@ -1,67 +0,0 @@
-import { convertDocument } from './convertDocument';
-
-describe('convertDocument', () => {
-  const fetchMock = jest.fn();
-
-  beforeEach(() => {
-    fetchMock.mockReset();
-    globalThis.fetch = fetchMock as unknown as typeof fetch;
-  });
-
-  it('uploads a file through the session-gated endpoint', async () => {
-    fetchMock.mockResolvedValue({
-      ok: true,
-      json: jest.fn().mockResolvedValue({ text: '# Converted document' }),
-    });
-    const file = new File(['document'], 'contract.pdf', {
-      type: 'application/pdf',
-    });
-
-    await expect(
-      convertDocument(file, 'session/id', 'https://www.aisuru.com/')
-    ).resolves.toBe('# Converted document');
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      'https://www.aisuru.com/api/convert/session%2Fid',
-      expect.objectContaining({
-        method: 'POST',
-        body: expect.any(FormData),
-      })
-    );
-    const body = fetchMock.mock.calls[0][1].body as FormData;
-    expect(body.get('file')).toBe(file);
-    expect(fetchMock.mock.calls[0][1].headers).toBeUndefined();
-  });
-
-  it('uses the current origin when baseUrl is omitted', async () => {
-    fetchMock.mockResolvedValue({
-      ok: true,
-      json: jest.fn().mockResolvedValue({ text: 'Converted' }),
-    });
-
-    await convertDocument(new File(['text'], 'notes.txt'), 'session');
-
-    expect(fetchMock).toHaveBeenCalledWith(
-      '/api/convert/session',
-      expect.any(Object)
-    );
-  });
-
-  it('surfaces conversion API errors', async () => {
-    fetchMock.mockResolvedValue({
-      ok: false,
-      json: jest.fn().mockResolvedValue({ error: 'Formato non supportato' }),
-    });
-
-    await expect(
-      convertDocument(new File(['document'], 'contract.pages'), 'session')
-    ).rejects.toThrow('Formato non supportato');
-  });
-
-  it('requires a session before uploading', async () => {
-    await expect(
-      convertDocument(new File(['document'], 'contract.pdf'), '')
-    ).rejects.toThrow('Session ID is required');
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-});

package/src/helpers/convertDocument.ts

@@ -1,35 +0,0 @@
-type ConvertDocumentResponse = {
-  text?: string;
-  error?: string;
-};
-
-export const convertDocument = async (
-  file: File,
-  sessionID: string,
-  baseUrl = ''
-): Promise<string> => {
-  if (!sessionID) {
-    throw new Error('Session ID is required to convert documents');
-  }
-
-  const body = new FormData();
-  body.append('file', file);
-
-  const origin = baseUrl.replace(/\/+$/, '');
-  const response = await fetch(
-    `${origin}/api/convert/${encodeURIComponent(sessionID)}`,
-    {
-      method: 'POST',
-      body,
-    }
-  );
-  const payload = (await response
-    .json()
-    .catch(() => null)) as ConvertDocumentResponse | null;
-
-  if (!response.ok || !payload?.text) {
-    throw new Error(payload?.error || 'Document conversion failed');
-  }
-
-  return payload.text;
-};

package/src/helpers/credits.ts

@@ -1,54 +0,0 @@
-// POST http://localhost:3000/api/verify-tokens operation=session_creation userID=585ec0ff-e805-495e-b8fc-5b0b8dd288ff tenant=aisuru-staging-tokenized.aclambda.online
-export type CreditsOperation =
-  | 'twin_creation'
-  | 'session_creation'
-  | 'import_document'
-  // accepted by the API and normalized to session_creation
-  | 'dt_session_creation';
-
-export const getCredits = async ({
-  operation = 'session_creation',
-  baseUrl,
-  userID,
-  userName,
-  tenant,
-  characters,
-}: {
-  operation?: CreditsOperation;
-  baseUrl: string;
-  userID?: string | null;
-  userName?: string | null;
-  tenant: string;
-  characters?: number;
-}): Promise<{
-  enough: boolean;
-  required: number;
-  tokens?: number;
-}> => {
-  if (!userID && !userName) {
-    throw new Error('Either userID or userName must be provided');
-  }
-  if (operation === 'import_document' && characters == null) {
-    throw new Error('characters must be provided for import_document');
-  }
-
-  const resp = await fetch(`${baseUrl}/api/verify-tokens`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      operation,
-      userID,
-      userName,
-      tenant,
-      ...(operation === 'import_document' ? { characters } : {}),
-    }),
-  });
-
-  if (!resp.ok) {
-    throw new Error('Failed to fetch credits');
-  }
-
-  return resp.json();
-};

package/src/helpers/error.test.ts

@@ -1,29 +0,0 @@
-import { getErrori18nKey } from './error';
-
-describe('Error helper for HTTP status codes', () => {
-  it('gets error i18n key correctly for 401', () => {
-    expect(getErrori18nKey(401)).toBe('error.unauthorized');
-  });
-
-  it('gets error i18n key correctly for 404', () => {
-    expect(getErrori18nKey(404)).toBe('error.notFound');
-  });
-
-  it('gets error i18n key correctly for 500', () => {
-    expect(getErrori18nKey(500)).toBe('internal server error');
-  });
-
-  it('gets error i18n key correctly for 501', () => {
-    expect(getErrori18nKey(501)).toBe('error.generic');
-  });
-});
-
-describe('Error helper for backend error codes', () => {
-  it('gets error i18n key correctly for -101', () => {
-    expect(getErrori18nKey(-101)).toBe('errors.SESSION_NOT_FOUND');
-  });
-
-  it('gets error i18n key correctly for -51', () => {
-    expect(getErrori18nKey(-51)).toBe('errors.MEMORI_NOT_FOUND');
-  });
-});