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	1032	* @typedef {object} Entity - Object representing a display entity
1036	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(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() {
 + */
     constexport nowfunction =humanizedDateTime(timestamp new= Date(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${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 monthdate = months[d.getMonthnew Date(timestamp)];
     const day =return ddate.getDatetoISOString();
 -    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 (_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 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.
  */
 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_idchatId, 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';
 /**
  * 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: humanizedISO8601DateTimenew Date().toISOString(),
         };
+    }
     /**

      * @returns {string} Chat data
      */
     static getChatFromScenario(scenario, userName, characterName, chatBackgrounds) {
         const chatStartDate = scenario?.messages?.length == 0 ? humanizedISO8601DateTimenew 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, humanizedISO8601DateTimehumanizedDateTime, 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'] || humanizedISO8601DateTimenew 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 = humanizedISO8601DateTimenew Date().toISOString();
+        }
     } else {
         jsonObject = readFromV2(jsonObject);

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

         char[charField] = v2Value;
     });
     char['chat'] = char['chat'] ?? humanizedISO8601DateTime`${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 + ' - ' + humanizedISO8601DateTimehumanizedDateTime());
     _.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': humanizedISO8601DateTimenew Date().toISOString(),
         'chat': `${yamlData.name} - ${humanizedISO8601DateTimehumanizedDateTime()}`,
         'personality': '',
         'creatorcomment': '',
         'avatar': 'none',

+    }
     unsetPrivateFields(card);
     card['create_date'] = humanizedISO8601DateTimenew 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} - ${humanizedISO8601DateTimehumanizedDateTime()} 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'] = humanizedISO8601DateTimenew 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 + ' - ' + humanizedISO8601DateTimehumanizedDateTime(),
             'mes_example': jsonData.mes_example ?? '',
             'scenario': jsonData.scenario ?? '',
             'create_date': humanizedISO8601DateTimenew Date().toISOString(),
             'talkativeness': jsonData.talkativeness ?? 0.5,
             'creator': jsonData.creator ?? '',
             'tags': jsonData.tags ?? '',

             'personality': '',
             'first_mes': jsonData.char_greeting ?? '',
             'avatar': 'none',
             'chat': jsonData.name + ' - ' + humanizedISO8601DateTimehumanizedDateTime(),
             'mes_example': jsonData.example_dialogue ?? '',
             'scenario': jsonData.world_scenario ?? '',
             'create_date': humanizedISO8601DateTimenew 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'] = humanizedISO8601DateTimenew 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 + ' - ' + humanizedISO8601DateTimehumanizedDateTime(),
             'mes_example': jsonData.mes_example ?? '',
             'scenario': jsonData.scenario ?? '',
             'create_date': humanizedISO8601DateTimenew 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,
     humanizedISO8601DateTimehumanizedDateTime,
     tryParse,
     generateTimestamp,
     removeOldBackups,

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

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

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

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

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

      */
     function convert(history) {
         const starter = {
             user_namechat_metadata: userName{},
 -            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: humanizedISO8601DateTimenew 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: new Date().nowtoISOString(),
 +            extra: {},
         };
+    }

 function importRisuChat(userName, characterName, jsonData) {
     /** @type {object[]} */
     const chat = [{
         user_namechat_metadata: userName{},
 -        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: 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'] || new Date(Math.round(stats.mtimeMs)).toISOString();
                     res(chatData);
                 } else {

             return response.sendStatus(400);
+        }
         const chatname = humanizedISO8601DateTimehumanizedDateTime();
         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} - ${humanizedISO8601DateTimehumanizedDateTime()} 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} - ${humanizedISO8601DateTimehumanizedDateTime()} 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.roundnew 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 { 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'] = humanizedISO8601DateTimenew 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. UnixDate.now timestamps (the number of secondsmilliseconds since the Unix Epoch)
  * 2. ST "humanized" timestamps, formatted like "`YYYY-MM-DD @HHh MMm SSs ms"HHhMMmSSsMSms`
  * 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|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
  * timestampToMomentparseTimestamp(1609459200);
  * // ST humanized timestamp
  * timestampToMomentparseTimestamp("2021-01-01 \@00h 00m 00s 000ms");
  * // Date string
  * timestampToMomentparseTimestamp("January 1, 2021 12:00am");
  */
 function timestampToMomentparseTimestamp(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 replacement1unixTime = 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(
 -            2,
 -            '0',
 -        )}T${hour.padStart(2, '0')}:${minute.padStart(
 -            2,
 -            '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 });
 -            2,
++
 -            '0',
 +    // ST "humanized" format patterns
 -        )}T${hour24.toString().padStart(2, '0')}:${minute.padStart(
 +    const convertFromHumanized = (_, year, month, day, hour, min, sec, ms) => {
 -            2,
 +        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(timestampToMomentparseTimestamp(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) {