Unify chat timestamps format (#4806) * Unify chat timestamps format * Handle ISO timestamps in stats.js * Refactor timestamp parsing on server * Switch to ISO timestamps for character/messages creation dates * Fix type error * Early exist in saveGroupChat if group not found * Remove redundant fields from temp.chat export header * Auto-fix char creation date format on edit * Add name to fallback chat file names * Rename parseTimestamp server side function

5993084ee6ebd887625fa4a8404d21e56ab69f32

Cohee <18619528+Cohee1207@users.noreply.github.com>

Signed

Parents: b9cea60c022351f99c20d231717112c52969863e

public/script.js+1 -4 Viewed

@@ -1028,9 +1028,6 @@ function verifyCharactersSearchSortRule() {
1028	}	1028	}
1029	}	1029	}
1030		1030
1031	/** @typedef {object} Character - A character */
1032	/** @typedef {object} Group - A group */
1033
1034	/**	1031	/**
1035	* @typedef {object} Entity - Object representing a display entity	1032	* @typedef {object} Entity - Object representing a display entity
1036	* @property {Character\|Group\|import('./scripts/tags.js').Tag\|*} item - The item	1033	* @property {Character\|Group\|import('./scripts/tags.js').Tag\|*} item - The item

     $('#talkativeness_slider').val(characters[chid].talkativeness || talkativeness_default);
     $('#mes_example_textarea').val(characters[chid].mes_example);
     $('#selected_chat_pole').val(characters[chid].chat);
-    $('#create_date_pole').val(characters[chid].create_date);
+    $('#create_date_pole').val(timestampToMoment(characters[chid].create_date).toISOString());
     $('#avatar_url_pole').val(characters[chid].avatar);
     $('#chat_import_avatar_url').val(characters[chid].avatar);
     $('#chat_import_character_name').val(characters[chid].name);

public/scripts/RossAscends-mods.js+25 -31 Viewed

+    }
+}
-//RossAscends: Added function to format dates used in files and chat timestamps to a humanized format.
+/**
-//Mostly I wanted this to be for file names, but couldn't figure out exactly where the filename save code was as everything seemed to be connected.
+ * Gets a humanized date time string from a given timestamp.
-//Does not break old characters/chats, as the code just uses whatever timestamp exists in the chat.
+ * @param {number} timestamp Timestamp in milliseconds
-//New chats made with characters will use this new formatting.
+ * @returns {string} Humanized date time string in the format `YYYY-MM-DD@HHhMMmSSsMSms`
-export function humanizedDateTime() {
+ */
-    const now = new Date(Date.now());
+export function humanizedDateTime(timestamp = Date.now()) {
+    const date = new Date(timestamp);
     const dt = {
-        year: now.getFullYear(), month: now.getMonth() + 1, day: now.getDate(),
+        year: date.getFullYear(),
-        hour: now.getHours(), minute: now.getMinutes(), second: now.getSeconds(),
+        month: date.getMonth() + 1,
+        day: date.getDate(),
+        hour: date.getHours(),
+        minute: date.getMinutes(),
+        second: date.getSeconds(),
+        millisecond: date.getMilliseconds(),
     };
     for (const key in dt) {
-        dt[key] = dt[key].toString().padStart(2, '0');
+        const padLength = key === 'millisecond' ? 3 : 2;
+        dt[key] = dt[key].toString().padStart(padLength, '0');
+    }
-    return `${dt.year}-${dt.month}-${dt.day}@${dt.hour}h${dt.minute}m${dt.second}s`;
+    return `${dt.year}-${dt.month}-${dt.day}@${dt.hour}h${dt.minute}m${dt.second}s${dt.millisecond}ms`;
+}
-//this is a common format version to display a timestamp on each chat message
+/**
-//returns something like: June 19, 2023 2:20pm
+ * Gets a timestamp for messages in ISO 8601 format.
-export function getMessageTimeStamp() {
+ * @param {number} timestamp - optional timestamp in milliseconds
-    const date = Date.now();
+ * @returns {string} ISO 8601 formatted timestamp
-    const months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+ */
-    const d = new Date(date);
+export function getMessageTimeStamp(timestamp = Date.now()) {
-    const month = months[d.getMonth()];
+    const date = new Date(timestamp);
-    const day = d.getDate();
+    return date.toISOString();
-    const year = d.getFullYear();
-    let hours = d.getHours();
-    const minutes = ('0' + d.getMinutes()).slice(-2);
-    let meridiem = 'am';
-    if (hours >= 12) {
-        meridiem = 'pm';
-        hours -= 12;
-    }
-    if (hours === 0) {
-        hours = 12;
-    }
-    const formattedDate = month + ' ' + day + ', ' + year + ' ' + hours + ':' + minutes + meridiem;
-    return formattedDate;
+}

public/scripts/chats.js+2 -7 Viewed

     event_types,
     getCurrentChatId,
     getRequestHeaders,
-    name1,
     name2,
     reloadCurrentChat,
     saveSettingsDebounced,

         await viewMessageFile(messageId, fileIndex);
     });
-    $(document).on('click', '.assistant_note_export', async function () {
+    $(document).on('click', '.assistant_note_export', async function (_e) {
         const chatToSave = [
-            {
+            { chat_metadata: chat_metadata },
-                user_name: name1,
-                character_name: name2,
-                chat_metadata: chat_metadata,
-            },
             ...chat.filter(x => x?.extra?.type !== system_message_types.ASSISTANT_NOTE),
         ];

public/scripts/extensions/stable-diffusion/index.js+1 -1 Viewed

     if (context.groupId) {
         const groupMembers = context.groups.find(x => x.id === context.groupId)?.members;
         const lastMessageAvatar = context.chat?.filter(x => !x.is_system && !x.is_user)?.slice(-1)[0]?.original_avatar;
-        const randomMemberAvatar = Array.isArray(groupMembers) ? groupMembers[Math.floor(Math.random() * groupMembers.length)]?.avatar : null;
+        const randomMemberAvatar = Array.isArray(groupMembers) ? groupMembers[Math.floor(Math.random() * groupMembers.length)] : null;
         const avatarToUse = lastMessageAvatar || randomMemberAvatar;
         return formatCharacterAvatar(avatarToUse);
     } else {

public/scripts/group-chats.js+7 -3 Viewed

  * Retrieves the members of a group
+ *
  * @param {string} [groupId=selected_group] - The ID of the group to retrieve members from. Defaults to the currently selected group.
- * @returns {import('../script.js').Character[]} An array of character objects representing the members of the group. If the group is not found, an empty array is returned.
+ * @returns {Character[]} An array of character objects representing the members of the group. If the group is not found, an empty array is returned.
  */
 export function getGroupMembers(groupId = selected_group) {
     const group = groups.find((x) => x.id === groupId);

  */
 async function saveGroupChat(groupId, shouldSaveGroup, force = false) {
     const group = groups.find(x => x.id == groupId);
-    const chat_id = group.chat_id;
+    if (!group) {
+        console.warn('Group not found', groupId);
+        return;
+    }
+    const chatId = group.chat_id;
     group['date_last_chat'] = Date.now();
     /** @type {ChatHeader} */
     const chatHeader = {

     const response = await fetch('/api/chats/group/save', {
         method: 'POST',
         headers: getRequestHeaders(),
-        body: JSON.stringify({ id: chat_id, chat: [chatHeader, ...chat], force: force }),
+        body: JSON.stringify({ id: chatId, chat: [chatHeader, ...chat], force: force }),
     });
     if (!response.ok) {

public/scripts/utils.js+2 -0 Viewed

         ms = typeof ms !== 'undefined' ? `.${ms.padStart(3, '0')}` : '';
         return `${year.padStart(4, '0')}-${month.padStart(2, '0')}-${day.padStart(2, '0')}T${hour.padStart(2, '0')}:${min.padStart(2, '0')}:${sec.padStart(2, '0')}${ms}Z`;
     };
+    // 2024-07-12@01h31m37s123ms
+    dtFmt.push({ callback: convertFromHumanized, pattern: /(\d{4})-(\d{1,2})-(\d{1,2})@(\d{1,2})h(\d{1,2})m(\d{1,2})s(\d{1,3})ms/ });
     // 2024-7-12@01h31m37s
     dtFmt.push({ callback: convertFromHumanized, pattern: /(\d{4})-(\d{1,2})-(\d{1,2})@(\d{1,2})h(\d{1,2})m(\d{1,2})s/ });
     // 2024-6-5 @14h 56m 50s 682ms

src/byaf.js+3 -6 Viewed

 import path from 'node:path';
 import urlJoin from 'url-join';
 import { DEFAULT_AVATAR_PATH } from './constants.js';
-import { extractFileFromZipBuffer, humanizedISO8601DateTime } from './util.js';
+import { extractFileFromZipBuffer } from './util.js';
 /**
  * A parser for BYAF (Backyard Archive Format) files.

                 extensions: { ...(character?.displayName && { 'display_name': character?.displayName }) }, // Preserve display name unmodified using extensions. "display_name" is not used by SillyTavern currently.
             },
             // @ts-ignore Non-standard spec extension
-            create_date: humanizedISO8601DateTime(),
+            create_date: new Date().toISOString(),
         };
+    }
     /**

      * @returns {string} Chat data
      */
     static getChatFromScenario(scenario, userName, characterName, chatBackgrounds) {
-        const chatStartDate = scenario?.messages?.length == 0 ? humanizedISO8601DateTime() : scenario?.messages?.filter(m => 'createdAt' in m)[0].createdAt;
+        const chatStartDate = scenario?.messages?.length == 0 ? new Date().toISOString() : scenario?.messages?.filter(m => 'createdAt' in m)[0].createdAt;
         const chatBackground = chatBackgrounds.find(bg => bg.paths.includes(scenario?.backgroundImage || ''))?.name || '';
         /** @type {object[]} */
         const chat = [{
-            user_name: userName,
-            character_name: characterName,
-            create_date: chatStartDate,
             chat_metadata: {
                 scenario: scenario?.narrative ?? '',
                 mes_example: ByafParser.formatExampleMessages(scenario?.exampleMessages),

src/endpoints/characters.js+18 -21 Viewed

 import { AVATAR_WIDTH, AVATAR_HEIGHT, DEFAULT_AVATAR_PATH } from '../constants.js';
 import { default as validateAvatarUrlMiddleware, getFileNameValidationFunction } from '../middleware/validateFileName.js';
-import { deepMerge, humanizedISO8601DateTime, tryParse, extractFileFromZipBuffer, MemoryLimitedMap, getConfigValue, mutateJsonString, clientRelativePath, getUniqueName, sanitizeSafeCharacterReplacements } from '../util.js';
+import { deepMerge, humanizedDateTime, tryParse, extractFileFromZipBuffer, MemoryLimitedMap, getConfigValue, mutateJsonString, clientRelativePath, getUniqueName, sanitizeSafeCharacterReplacements } from '../util.js';
 import { TavernCardValidator } from '../validator/TavernCardValidator.js';
 import { parse, read, write } from '../character-card-parser.js';
 import { readWorldInfoFile } from './worldinfo.js';

         character['json_data'] = imgData;
         const charStat = fs.statSync(path.join(directories.characters, item));
         character['date_added'] = charStat.ctimeMs;
-        character['create_date'] = jsonObject['create_date'] || humanizedISO8601DateTime(charStat.ctimeMs);
+        character['create_date'] = jsonObject['create_date'] || new Date(Math.round(charStat.ctimeMs)).toISOString();
         const chatsDirectory = path.join(directories.chats, item.replace('.png', ''));
         const { chatSize, dateLastChat } = calculateChatSize(chatsDirectory);

         jsonObject = convertToV2(jsonObject, directories);
         if (hoistDate && !jsonObject.create_date) {
-            jsonObject.create_date = humanizedISO8601DateTime();
+            jsonObject.create_date = new Date().toISOString();
+        }
     } else {
         jsonObject = readFromV2(jsonObject);

         depth_prompt_role: char.depth_prompt_role,
     }, directories);
-    result.chat = char.chat ?? humanizedISO8601DateTime();
+    result.chat = char.chat ?? `${char.name} - ${humanizedDateTime()}`;
     result.create_date = char.create_date;
     return result;

         char[charField] = v2Value;
     });
-    char['chat'] = char['chat'] ?? humanizedISO8601DateTime();
+    char['chat'] = char['chat'] ?? `${char.name} - ${humanizedDateTime()}`;
     return char;
+}

     // Old ST extension fields (for backward compatibility, will be deprecated)
     _.set(char, 'creatorcomment', data.creator_notes || '');
     _.set(char, 'avatar', 'none');
-    _.set(char, 'chat', data.ch_name + ' - ' + humanizedISO8601DateTime());
+    _.set(char, 'chat', data.ch_name + ' - ' + humanizedDateTime());
     _.set(char, 'talkativeness', data.talkativeness || 0.5);
     _.set(char, 'fav', data.fav == 'true');
     _.set(char, 'tags', typeof data.tags == 'string' ? (data.tags.split(',').map(x => x.trim()).filter(x => x)) : data.tags || []);

     _.set(char, 'data.extensions.depth_prompt.prompt', data.depth_prompt_prompt ?? '');
     _.set(char, 'data.extensions.depth_prompt.depth', depth_value);
     _.set(char, 'data.extensions.depth_prompt.role', role_value);
-    //_.set(char, 'data.extensions.create_date', humanizedISO8601DateTime());
-    //_.set(char, 'data.extensions.avatar', 'none');
-    //_.set(char, 'data.extensions.chat', data.ch_name + ' - ' + humanizedISO8601DateTime());
     // V3 fields
     _.set(char, 'data.group_only_greetings', data.group_only_greetings ?? []);

         'name': yamlData.name,
         'description': yamlData.context ?? '',
         'first_mes': yamlData.greeting ?? '',
-        'create_date': humanizedISO8601DateTime(),
+        'create_date': new Date().toISOString(),
-        'chat': `${yamlData.name} - ${humanizedISO8601DateTime()}`,
+        'chat': `${yamlData.name} - ${humanizedDateTime()}`,
         'personality': '',
         'creatorcomment': '',
         'avatar': 'none',

+    }
     unsetPrivateFields(card);
-    card['create_date'] = humanizedISO8601DateTime();
+    card['create_date'] = new Date().toISOString();
     card.name = sanitize(card.name);
     const fileName = preservedFileName || getPngName(card.name, request.user.directories);
     const result = await writeCharacterData(avatar, JSON.stringify(card), fileName, request);

          * @param {Partial<ByafScenario>} scenario
         */
         const createChatAsCurrentPersona = (scenario) => {
-            const chatName = sanitize(`${scenario.title || card.name} - ${humanizedISO8601DateTime()} imported.jsonl`, { replacement: sanitizeSafeCharacterReplacements });
+            const chatName = sanitize(`${scenario.title || card.name} - ${humanizedDateTime()} imported.jsonl`, { replacement: sanitizeSafeCharacterReplacements });
             const filePath = path.join(request.user.directories.chats, path.basename(fileName), chatName);
             const dir = path.dirname(filePath);
             if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });

         importRisuSprites(request.user.directories, jsonData);
         unsetPrivateFields(jsonData);
         jsonData = readFromV2(jsonData);
-        jsonData['create_date'] = humanizedISO8601DateTime();
+        jsonData['create_date'] = new Date().toISOString();
         const pngName = preservedFileName || getPngName(jsonData.data?.name || jsonData.name, request.user.directories);
         const char = JSON.stringify(jsonData);
         const result = await writeCharacterData(DEFAULT_AVATAR_PATH, char, pngName, request);

             'personality': jsonData.personality ?? '',
             'first_mes': jsonData.first_mes ?? '',
             'avatar': 'none',
-            'chat': jsonData.name + ' - ' + humanizedISO8601DateTime(),
+            'chat': jsonData.name + ' - ' + humanizedDateTime(),
             'mes_example': jsonData.mes_example ?? '',
             'scenario': jsonData.scenario ?? '',
-            'create_date': humanizedISO8601DateTime(),
+            'create_date': new Date().toISOString(),
             'talkativeness': jsonData.talkativeness ?? 0.5,
             'creator': jsonData.creator ?? '',
             'tags': jsonData.tags ?? '',

             'personality': '',
             'first_mes': jsonData.char_greeting ?? '',
             'avatar': 'none',
-            'chat': jsonData.name + ' - ' + humanizedISO8601DateTime(),
+            'chat': jsonData.name + ' - ' + humanizedDateTime(),
             'mes_example': jsonData.example_dialogue ?? '',
             'scenario': jsonData.world_scenario ?? '',
-            'create_date': humanizedISO8601DateTime(),
+            'create_date': new Date().toISOString(),
             'talkativeness': jsonData.talkativeness ?? 0.5,
             'creator': jsonData.creator ?? '',
             'tags': jsonData.tags ?? '',

         importRisuSprites(request.user.directories, jsonData);
         unsetPrivateFields(jsonData);
         jsonData = readFromV2(jsonData);
-        jsonData['create_date'] = humanizedISO8601DateTime();
+        jsonData['create_date'] = new Date().toISOString();
         const char = JSON.stringify(jsonData);
         const result = await writeCharacterData(uploadPath, char, pngName, request);
         fs.unlinkSync(uploadPath);

             'personality': jsonData.personality ?? '',
             'first_mes': jsonData.first_mes ?? '',
             'avatar': 'none',
-            'chat': jsonData.name + ' - ' + humanizedISO8601DateTime(),
+            'chat': jsonData.name + ' - ' + humanizedDateTime(),
             'mes_example': jsonData.mes_example ?? '',
             'scenario': jsonData.scenario ?? '',
-            'create_date': humanizedISO8601DateTime(),
+            'create_date': new Date().toISOString(),
             'talkativeness': jsonData.talkativeness ?? 0.5,
             'creator': jsonData.creator ?? '',
             'tags': jsonData.tags ?? '',

src/endpoints/chats.js+22 -24 Viewed

 import validateAvatarUrlMiddleware from '../middleware/validateFileName.js';
 import {
     getConfigValue,
-    humanizedISO8601DateTime,
+    humanizedDateTime,
     tryParse,
     generateTimestamp,
     removeOldBackups,

 function importOobaChat(userName, characterName, jsonData) {
     /** @type {object[]} */
     const chat = [{
-        user_name: userName,
+        chat_metadata: {},
-        character_name: characterName,
-        create_date: humanizedISO8601DateTime(),
     }];
     for (const arr of jsonData.data_visible) {

             const userMessage = {
                 name: userName,
                 is_user: true,
-                send_date: humanizedISO8601DateTime(),
+                send_date: new Date().toISOString(),
                 mes: arr[0],
+                extra: {},
             };
             chat.push(userMessage);
+        }

             const charMessage = {
                 name: characterName,
                 is_user: false,
-                send_date: humanizedISO8601DateTime(),
+                send_date: new Date().toISOString(),
                 mes: arr[1],
+                extra: {},
             };
             chat.push(charMessage);
+        }

 function importAgnaiChat(userName, characterName, jsonData) {
     /** @type {object[]} */
     const chat = [{
-        user_name: userName,
+        chat_metadata: {},
-        character_name: characterName,
-        create_date: humanizedISO8601DateTime(),
     }];
     for (const message of jsonData.messages) {

         chat.push({
             name: isUser ? userName : characterName,
             is_user: isUser,
-            send_date: humanizedISO8601DateTime(),
+            send_date: new Date().toISOString(),
             mes: message.msg,
+            extra: {},
         });
+    }

      */
     function convert(history) {
         const starter = {
-            user_name: userName,
+            chat_metadata: {},
-            character_name: characterName,
-            create_date: humanizedISO8601DateTime(),
         };
         const historyData = history.msgs.map((msg) => ({
             name: msg.src.is_human ? userName : characterName,
             is_user: msg.src.is_human,
-            send_date: humanizedISO8601DateTime(),
+            send_date: new Date().toISOString(),
             mes: msg.text,
+            extra: {},
         }));
         return [starter, ...historyData];

             name: isUser ? header.user_name : header.character_name,
             is_user: isUser,
             mes: msg.replaceAll(inputToken, '').replaceAll(outputToken, '').trim(),
-            send_date: Date.now(),
+            send_date: new Date().toISOString(),
+            extra: {},
         };
+    }

 function importRisuChat(userName, characterName, jsonData) {
     /** @type {object[]} */
     const chat = [{
-        user_name: userName,
+        chat_metadata: {},
-        character_name: characterName,
-        create_date: humanizedISO8601DateTime(),
     }];
     for (const message of jsonData.data.message) {

         chat.push({
             name: message.name ?? (isUser ? userName : characterName),
             is_user: isUser,
-            send_date: Number(message.time ?? Date.now()),
+            send_date: new Date(Number(message.time ?? Date.now())).toISOString(),
             mes: message.data ?? '',
+            extra: {},
         });
+    }

                 if (jsonData && (jsonData.name || jsonData.character_name || jsonData.chat_metadata)) {
                     chatData.chat_items = (itemCounter - 1);
                     chatData.mes = jsonData['mes'] || '[The message is empty]';
-                    chatData.last_mes = jsonData['send_date'] || stats.mtimeMs;
+                    chatData.last_mes = jsonData['send_date'] || new Date(Math.round(stats.mtimeMs)).toISOString();
                     res(chatData);
                 } else {

             return response.sendStatus(400);
+        }
-        const chatname = humanizedISO8601DateTime();
+        const chatname = humanizedDateTime();
         const pathToUpload = path.join(filedata.destination, filedata.filename);
         const pathToNewFile = path.join(request.user.directories.groupChats, `${chatname}.jsonl`);
         fs.copyFileSync(pathToUpload, pathToNewFile);

+            }
             const handleChat = (chat) => {
-                const fileName = `${characterName} - ${humanizedISO8601DateTime()} imported.jsonl`;
+                const fileName = `${characterName} - ${humanizedDateTime()} imported.jsonl`;
                 const filePath = path.join(request.user.directories.chats, avatarUrl, fileName);
                 fileNames.push(fileName);
                 writeFileAtomicSync(filePath, chat, 'utf8');

                 console.warn('Failed to flatten Chub Chat data: ', error);
+            }
-            const fileName = `${characterName} - ${humanizedISO8601DateTime()} imported.jsonl`;
+            const fileName = `${characterName} - ${humanizedDateTime()} imported.jsonl`;
             const filePath = path.join(request.user.directories.chats, avatarUrl, fileName);
             fileNames.push(fileName);
             if (flattenedChat !== data) {

+            }
             const lastMessage = messages[messages.length - 1];
-            const lastMesDate = lastMessage?.send_date || Math.round(fs.statSync(chatFile.path).mtimeMs);
+            const lastMesDate = lastMessage?.send_date || new Date(fs.statSync(chatFile.path).mtimeMs).toISOString();
             // If no search query, just return metadata
             if (!query) {

src/endpoints/groups.js+2 -2 Viewed

 import sanitize from 'sanitize-filename';
 import { sync as writeFileAtomicSync, default as writeFileAtomic } from 'write-file-atomic';
-import { color, humanizedISO8601DateTime, tryParse } from '../util.js';
+import { color, tryParse } from '../util.js';
 import { getFileNameValidationFunction } from '../middleware/validateFileName.js';
 export const router = express.Router();

             const group = JSON.parse(fileContents);
             const groupStat = fs.statSync(filePath);
             group['date_added'] = groupStat.birthtimeMs;
-            group['create_date'] = humanizedISO8601DateTime(groupStat.birthtimeMs);
+            group['create_date'] = new Date(groupStat.birthtimeMs).toISOString();
             let chat_size = 0;
             let date_last_chat = 0;

src/endpoints/stats.js+67 -65 Viewed

 const STATS_FILE = 'stats.json';
+const monthNames = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
 /**
  * @type {Map<string, Object>} The stats object for each user.
  */

 /**
  * Convert a timestamp to an integer timestamp.
- * (sorry, it's momentless for now, didn't want to add a package just for this)
  * This function can handle several different timestamp formats:
- * 1. Unix timestamps (the number of seconds since the Unix Epoch)
+ * 1. Date.now timestamps (the number of milliseconds since the Unix Epoch)
- * 2. ST "humanized" timestamps, formatted like "YYYY-MM-DD @HHh MMm SSs ms"
+ * 2. ST "humanized" timestamps, formatted like `YYYY-MM-DD@HHhMMmSSsMSms`
- * 3. Date strings in the format "Month DD, YYYY H:MMam/pm"
+ * 3. Date strings in the format `Month DD, YYYY H:MMam/pm`
+ * 4. ISO 8601 formatted strings
+ * 5. Date objects
+ *
  * The function returns the timestamp as the number of milliseconds since
  * the Unix Epoch, which can be converted to a JavaScript Date object with new Date().
+ *
- * @param {string|number} timestamp - The timestamp to convert.
+ * @param {string|number|Date} timestamp - The timestamp to convert.
  * @returns {number} The timestamp in milliseconds since the Unix Epoch, or 0 if the input cannot be parsed.
+ *
  * @example
  * // Unix timestamp
- * timestampToMoment(1609459200);
+ * parseTimestamp(1609459200);
  * // ST humanized timestamp
- * timestampToMoment("2021-01-01 \@00h 00m 00s 000ms");
+ * parseTimestamp("2021-01-01 \@00h 00m 00s 000ms");
  * // Date string
- * timestampToMoment("January 1, 2021 12:00am");
+ * parseTimestamp("January 1, 2021 12:00am");
  */
-function timestampToMoment(timestamp) {
+function parseTimestamp(timestamp) {
     if (!timestamp) {
         return 0;
+    }
-    if (typeof timestamp === 'number') {
+    // Date object
-        return timestamp;
+    if (timestamp instanceof Date) {
+        return timestamp.getTime();
+    }
-    const pattern1 =
+    // Unix time
-        /(\d{4})-(\d{1,2})-(\d{1,2}) @(\d{1,2})h (\d{1,2})m (\d{1,2})s (\d{1,3})ms/;
+    if (typeof timestamp === 'number' || /^\d+$/.test(timestamp)) {
-    const replacement1 = (
+        const unixTime = Number(timestamp);
-        match,
+        const isValid = Number.isFinite(unixTime) && !Number.isNaN(unixTime) && unixTime >= 0;
-        year,
+        if (!isValid) return 0;
-        month,
+        return new Date(unixTime).getTime();
-        day,
+    }
-        hour,
-        minute,
+    // ISO 8601 format
-        second,
+    const isoPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
-        millisecond,
+    if (isoPattern.test(timestamp)) {
-    ) => {
+        return new Date(timestamp).getTime();
-        return `${year}-${month.padStart(2, '0')}-${day.padStart(
-,
-            '0',
-        )}T${hour.padStart(2, '0')}:${minute.padStart(
-,
-            '0',
-        )}:${second.padStart(2, '0')}.${millisecond.padStart(3, '0')}Z`;
-    };
-    const isoTimestamp1 = timestamp.replace(pattern1, replacement1);
-    if (!isNaN(Number(new Date(isoTimestamp1)))) {
-        return new Date(isoTimestamp1).getTime();
+    }
-    const pattern2 = /(\w+)\s(\d{1,2}),\s(\d{4})\s(\d{1,2}):(\d{1,2})(am|pm)/i;
+    let dateFormats = [];
-    const replacement2 = (match, month, day, year, hour, minute, meridiem) => {
-        const monthNames = [
+    // meridiem-based format
-            'January',
+    const convertFromMeridiemBased = (_, month, day, year, hour, minute, meridiem) => {
-            'February',
-            'March',
-            'April',
-            'May',
-            'June',
-            'July',
-            'August',
-            'September',
-            'October',
-            'November',
-            'December',
-        ];
         const monthNum = monthNames.indexOf(month) + 1;
-        const hour24 =
+        const hour24 = meridiem.toLowerCase() === 'pm' ? (parseInt(hour, 10) % 12) + 12 : parseInt(hour, 10) % 12;
-            meridiem.toLowerCase() === 'pm'
+        return `${year}-${monthNum}-${day.padStart(2, '0')}T${hour24.toString().padStart(2, '0')}:${minute.padStart(2, '0')}:00`;
-                ? (parseInt(hour, 10) % 12) + 12
+    };
-                : parseInt(hour, 10) % 12;
+    // June 19, 2023 2:20pm
-        return `${year}-${monthNum.toString().padStart(2, '0')}-${day.padStart(
+    dateFormats.push({ callback: convertFromMeridiemBased, pattern: /(\w+)\s(\d{1,2}),\s(\d{4})\s(\d{1,2}):(\d{1,2})(am|pm)/i });
-,
-            '0',
+    // ST "humanized" format patterns
-        )}T${hour24.toString().padStart(2, '0')}:${minute.padStart(
+    const convertFromHumanized = (_, year, month, day, hour, min, sec, ms) => {
-,
+        ms = typeof ms !== 'undefined' ? `.${ms.padStart(3, '0')}` : '';
-            '0',
+        return `${year.padStart(4, '0')}-${month.padStart(2, '0')}-${day.padStart(2, '0')}T${hour.padStart(2, '0')}:${min.padStart(2, '0')}:${sec.padStart(2, '0')}${ms}Z`;
-        )}:00Z`;
     };
-    const isoTimestamp2 = timestamp.replace(pattern2, replacement2);
+    // 2024-07-12@01h31m37s123ms
-    if (!isNaN(Number(new Date(isoTimestamp2)))) {
+    dateFormats.push({ callback: convertFromHumanized, pattern: /(\d{4})-(\d{1,2})-(\d{1,2})@(\d{1,2})h(\d{1,2})m(\d{1,2})s(\d{1,3})ms/ });
-        return new Date(isoTimestamp2).getTime();
+    // 2024-7-12@01h31m37s
+    dateFormats.push({ callback: convertFromHumanized, pattern: /(\d{4})-(\d{1,2})-(\d{1,2})@(\d{1,2})h(\d{1,2})m(\d{1,2})s/ });
+    // 2024-6-5 @14h 56m 50s 682ms
+    dateFormats.push({ callback: convertFromHumanized, pattern: /(\d{4})-(\d{1,2})-(\d{1,2}) @(\d{1,2})h (\d{1,2})m (\d{1,2})s (\d{1,3})ms/ });
+    for (const x of dateFormats) {
+        const rgxMatch = timestamp.match(x.pattern);
+        if (!rgxMatch) continue;
+        const isoTimestamp = x.callback(...rgxMatch);
+        return new Date(isoTimestamp).getTime();
+    }
     return 0;

                 // If this is the first user message, set the first chat time
                 if (json.is_user) {
                     //get min between firstChatTime and timestampToMoment(json.send_date)
-                    firstChatTime = Math.min(timestampToMoment(json.send_date), firstChatTime);
+                    firstChatTime = Math.min(parseTimestamp(json.send_date), firstChatTime);
+                }
             } catch (error) {
                 console.error(`Error parsing line ${line}: ${error}`);

src/util.js+21 -11 Viewed

     });
+}
-export function humanizedISO8601DateTime(date) {
+/**
-    let baseDate = typeof date === 'number' ? new Date(date) : new Date();
+ * Gets a humanized date time string from a given timestamp.
-    let humanYear = baseDate.getFullYear();
+ * @param {number} timestamp Timestamp in milliseconds
-    let humanMonth = (baseDate.getMonth() + 1);
+ * @returns {string} Humanized date time string in the format `YYYY-MM-DD@HHhMMmSSsMSms`
-    let humanDate = baseDate.getDate();
+ */
-    let humanHour = (baseDate.getHours() < 10 ? '0' : '') + baseDate.getHours();
+export function humanizedDateTime(timestamp = Date.now()) {
-    let humanMinute = (baseDate.getMinutes() < 10 ? '0' : '') + baseDate.getMinutes();
+    const date = new Date(timestamp);
-    let humanSecond = (baseDate.getSeconds() < 10 ? '0' : '') + baseDate.getSeconds();
+    const dt = {
-    let humanMillisecond = (baseDate.getMilliseconds() < 10 ? '0' : '') + baseDate.getMilliseconds();
+        year: date.getFullYear(),
-    let HumanizedDateTime = (humanYear + '-' + humanMonth + '-' + humanDate + ' @' + humanHour + 'h ' + humanMinute + 'm ' + humanSecond + 's ' + humanMillisecond + 'ms');
+        month: date.getMonth() + 1,
-    return HumanizedDateTime;
+        day: date.getDate(),
+        hour: date.getHours(),
+        minute: date.getMinutes(),
+        second: date.getSeconds(),
+        millisecond: date.getMilliseconds(),
+    };
+    for (const key in dt) {
+        const padLength = key === 'millisecond' ? 3 : 2;
+        dt[key] = dt[key].toString().padStart(padLength, '0');
+    }
+    return `${dt.year}-${dt.month}-${dt.day}@${dt.hour}h${dt.minute}m${dt.second}s${dt.millisecond}ms`;
+}
 export function tryParse(str) {