Change timeblock display to have the time text from .content, and just shown as a prepended time lozenge.

Fix to missing endTime in timeblocks.

Author: jgclark

helpers/__tests__/timeblocks.test.js

@@ -506,4 +506,156 @@ describe(`${HELPER_NAME}`, () => {
       jest.useRealTimers() // Restore the real timers after each test
     })
   })
+
+  describe(section`stripTimeBlockAndMustContainFromContent()`, () => {
+    test('strips a start-end timeblock from mid-content without must-contain string', () => {
+      expect(tb.stripTimeBlockAndMustContainFromContent('Longer timeblocked task at 10:00-16:30')).toEqual('Longer timeblocked task at')
+    })
+
+    test('strips a start-end timeblock from mid-content with must-contain string', () => {
+      expect(tb.stripTimeBlockAndMustContainFromContent('Longer timeblocked task at 10:00-16:30', 'at')).toEqual('Longer timeblocked task')
+    })
+
+    test('strips a start-only timeblock', () => {
+      expect(tb.stripTimeBlockAndMustContainFromContent('Morning checklist 7:30AM')).toEqual('Morning checklist')
+    })
+
+    test('strips timeblock when it is at the start of the line', () => {
+      expect(tb.stripTimeBlockAndMustContainFromContent('10:00-11:00 Focus time')).toEqual('Focus time')
+    })
+
+    test('strips NotePlan must-contain string when set', () => {
+      expect(tb.stripTimeBlockAndMustContainFromContent('Meeting >anytime at 14:00-15:00', '>anytime at')).toEqual('Meeting')
+    })
+
+    test('strips must-contain hashtag and timeblock', () => {
+      expect(tb.stripTimeBlockAndMustContainFromContent('Deep work #tb 09:00-12:00', '#tb')).toEqual('Deep work')
+    })
+
+    test('strips must-contain hashtag separate from the timeblock', () => {
+      expect(tb.stripTimeBlockAndMustContainFromContent('#tb Deep work 09:00-12:00', '#tb')).toEqual('Deep work')
+    })
+
+    test('returns trimmed content unchanged when no timeblock present', () => {
+      expect(tb.stripTimeBlockAndMustContainFromContent('  no times here  ')).toEqual('no times here')
+    })
+
+    test('returns empty string for empty content', () => {
+      expect(tb.stripTimeBlockAndMustContainFromContent('')).toEqual('')
+    })
+
+    test('collapses leftover double spaces after strip', () => {
+      expect(tb.stripTimeBlockAndMustContainFromContent('Task  10:00-11:00  remaining')).toEqual('Task remaining')
+    })
+  })
+
+  describe(section`formatTimeBlockLabelFromStartAndEnd()`, () => {
+    test('formats start and end', () => {
+      expect(tb.formatTimeBlockLabelFromStartAndEnd('10:00', '16:30')).toEqual('10:00-16:30')
+    })
+
+    test('formats start only when end missing', () => {
+      expect(tb.formatTimeBlockLabelFromStartAndEnd('07:30')).toEqual('07:30')
+    })
+
+    test('returns empty when start is none or missing', () => {
+      expect(tb.formatTimeBlockLabelFromStartAndEnd('none', '16:30')).toEqual('')
+      expect(tb.formatTimeBlockLabelFromStartAndEnd(null)).toEqual('')
+      expect(tb.formatTimeBlockLabelFromStartAndEnd(undefined)).toEqual('')
+    })
+  })
+
+  describe(section`getEndTimeObjFromParaContent()`, () => {
+    test('parses 24h start-end without AM/PM', () => {
+      expect(tb.getEndTimeObjFromParaContent('TEST at 22:30-23:45')).toEqual({ hours: 23, mins: 45 })
+    })
+
+    test('returns NaN hours when there is no end time', () => {
+      const result = tb.getEndTimeObjFromParaContent('Something at 22:30')
+      expect(Number.isNaN(result.hours)).toBe(true)
+    })
+
+    test('parses en-dash separator', () => {
+      expect(tb.getEndTimeObjFromParaContent('Block 10:00–11:30')).toEqual({ hours: 11, mins: 30 })
+    })
+  })
+
+  describe(section`normalizeTimeBlockStartToHHMM()`, () => {
+    test('pads single-digit hour', () => {
+      expect(tb.normalizeTimeBlockStartToHHMM('9:00')).toEqual('09:00')
+    })
+
+    test('strips AM suffix', () => {
+      expect(tb.normalizeTimeBlockStartToHHMM('10:00AM')).toEqual('10:00')
+    })
+
+    test('converts PM to 24h', () => {
+      expect(tb.normalizeTimeBlockStartToHHMM('11:00 PM')).toEqual('23:00')
+    })
+
+    test('keeps noon as 12:00', () => {
+      expect(tb.normalizeTimeBlockStartToHHMM('12:00 PM')).toEqual('12:00')
+    })
+  })
+
+  describe(section`getStartTimeFromPara()`, () => {
+    test('should return 10:00 from 10:00-11:00', () => {
+      expect(tb.getStartTimeFromPara({ content: 'just a time range 10:00-11:00' })).toBe('10:00')
+    })
+    test('should return 10:00 from 10:00', () => {
+      expect(tb.getStartTimeFromPara({ content: 'just a time 10:00' })).toBe('10:00')
+    })
+    test('should return 10:00 from 10:00AM-11:00PM', () => {
+      expect(tb.getStartTimeFromPara({ content: '2025-05-09 10:00AM-11:00PM' })).toBe('10:00')
+    })
+    test('should return 10:00 from 10:00AM', () => {
+      expect(tb.getStartTimeFromPara({ content: '2025-05-09 10:00AM' })).toBe('10:00')
+    })
+    test('should return 10:00 from spaced AM', () => {
+      expect(tb.getStartTimeFromPara({ content: 'other text 10:00 AM' })).toBe('10:00')
+    })
+    test('should return 23:00 from 11:00 PM', () => {
+      expect(tb.getStartTimeFromPara({ content: 'other text 11:00 PM' })).toBe('23:00')
+    })
+    test('should return 12:00 from 12:00 PM (noon)', () => {
+      expect(tb.getStartTimeFromPara({ content: 'Lunch 12:00 PM' })).toBe('12:00')
+    })
+    test('should return 12:30 from 12:30 PM', () => {
+      expect(tb.getStartTimeFromPara({ content: 'Lunch 12:30 PM' })).toBe('12:30')
+    })
+    test('should return 09:00 from single-digit hour 9:00 AM', () => {
+      expect(tb.getStartTimeFromPara({ content: 'Standup 9:00 AM' })).toBe('09:00')
+    })
+    test('should return "none" if the para does not have a valid time', () => {
+      expect(tb.getStartTimeFromPara({ content: '2025-05-09 10-11' })).toBe('none')
+    })
+  })
+
+  describe(section`getEndTimeFromPara()`, () => {
+    test('returns normalised end from 24h range', () => {
+      expect(tb.getEndTimeFromPara({ content: 'TEST at 22:30-23:45' })).toBe('23:45')
+    })
+
+    test('returns undefined when there is no end', () => {
+      expect(tb.getEndTimeFromPara({ content: 'Something at 22:30' })).toBeUndefined()
+    })
+
+    test('normalises PM end time', () => {
+      expect(tb.getEndTimeFromPara({ content: 'Meeting 10:00AM-11:00PM' })).toBe('23:00')
+    })
+  })
+
+  describe(section`prepareTimeBlockContentForDisplay()`, () => {
+    test('puts normalised time at start conceptually (label + cleaned rest)', () => {
+      const result = tb.prepareTimeBlockContentForDisplay('Longer timeblocked task at 10:00-16:30', '10:00', '16:30', 'at')
+      expect(result.timeLabel).toEqual('10:00-16:30')
+      expect(result.restContent).toEqual('Longer timeblocked task')
+    })
+
+    test('handles must-contain string and start-only time', () => {
+      const result = tb.prepareTimeBlockContentForDisplay('Standup >anytime 09:00', '09:00', undefined, '>anytime')
+      expect(result.timeLabel).toEqual('09:00')
+      expect(result.restContent).toEqual('Standup')
+    })
+  })
 })

helpers/timeblocks.js

@@ -7,6 +7,7 @@ import moment from 'moment/min/moment-with-locales'
 import { clo, JSP, logDebug, logInfo, logError } from './dev'
 import { displayTitle } from './general'
 import { isTermInURL, stripAllURIsAndNoteLinks, stripDoneDateTimeMentions } from './paragraph'
+import { escapeRegExp } from './regexEscape'
 import { findLongestStringInArray } from './utils'
 
 // import { getTime } from "date-fns";
@@ -354,6 +355,69 @@ export function getEndTimeStrFromParaContent(content: string): string {
   }
 }
 
+/**
+ * Normalize a time-block segment to 24h HH:mm (e.g. "12:00PM" -> "12:00", "9:00 AM" -> "09:00").
+ * Works for either the start or end segment of a timeblock.
+ * @param {string} startTimeStrIn - text before or after '-' in a time block
+ * @returns {string}
+ */
+export function normalizeTimeBlockStartToHHMM(startTimeStrIn: string): string {
+  let startTimeStr = startTimeStrIn
+  if (startTimeStr.length > 0 && startTimeStr.length < 2) {
+    startTimeStr = `0${startTimeStr}`
+  } else if (startTimeStr.length > 1 && startTimeStr[1] === ':') {
+    startTimeStr = `0${startTimeStr}`
+  }
+  if (startTimeStr.endsWith('AM')) {
+    startTimeStr = startTimeStr.slice(0, 5)
+  }
+  if (startTimeStr.endsWith('PM')) {
+    const hour = Number(startTimeStr.slice(0, 2))
+    const adjustedHour = hour === 12 ? 12 : hour + 12
+    startTimeStr = String(adjustedHour).padStart(2, '0') + startTimeStr.slice(2, 5)
+  }
+  return startTimeStr
+}
+
+/**
+ * Return the normalised start time (HH:mm) from a paragraph's content timeblock, or 'none'.
+ * Copes with 'AM' and 'PM' suffixes. Not fully internationalised.
+ * @param {{ content: string }} para - anything with a .content string (TParagraph, dashboard para, etc.)
+ * @returns {string} e.g. '10:00', or 'none' / '(error)'
+ */
+export function getStartTimeFromPara(para: { content: string }): string {
+  try {
+    let startTimeStr = 'none'
+    const thisTimeStr = getTimeBlockString(para.content)
+    if (thisTimeStr !== '') {
+      startTimeStr = normalizeTimeBlockStartToHHMM(thisTimeStr.split(/[-–~]/)[0])
+    }
+    return startTimeStr
+  } catch (error) {
+    logError('getStartTimeFromPara', `${error.message}`)
+    return '(error)'
+  }
+}
+
+/**
+ * Return the normalised end time (HH:mm) from a paragraph's content timeblock, if present.
+ * Copes with 'AM' and 'PM' suffixes (same normalisation as getStartTimeFromPara).
+ * @param {{ content: string }} para - anything with a .content string (TParagraph, dashboard para, etc.)
+ * @returns {string | void} HH:mm end time, or undefined if none / error
+ */
+export function getEndTimeFromPara(para: { content: string }): string | void {
+  try {
+    const thisTimeStr = getTimeBlockString(para.content)
+    if (thisTimeStr === '') return
+    const endPart = thisTimeStr.split(/[-–~]/)[1]
+    if (!endPart) return
+    return normalizeTimeBlockStartToHHMM(endPart)
+  } catch (error) {
+    logError('getEndTimeFromPara', `${error.message}`)
+    return
+  }
+}
+
 /**
  * Return the start time of a time block in a given paragraph, or else 'none' (which will then sort after times)
  * Copes with 'AM' and 'PM' suffixes. Note: Not fully internationalised (but then I don't think the rest of NP accepts non-Western numerals)
@@ -394,36 +458,41 @@ export function getStartTimeObjFromParaContent(content: string): ?{ hours: numbe
 }
 
 /**
- * Return the end time of time block in a given paragraph, or else 'none' (which will then sort after times)
+ * Return the end time of time block in a given paragraph, or else empty NaN hours/mins when absent.
  * Copes with 'AM' and 'PM' suffixes. Note: Not fully internationalised (but then I don't think the rest of NP accepts non-Western numerals)
  * @param {string} content to process
- * @returns {{number, number}} {hours, minutes} in 24 hour clock
+ * @returns {{ hours: number, mins: number }} {hours, minutes} in 24 hour clock (NaN if no end time)
  */
 export function getEndTimeObjFromParaContent(content: string): { hours: number, mins: number } {
   try {
-    let endTimeStr = 'none'
     let hours = NaN
     let mins = NaN
     if (content !== '') {
       const thisTimeStr = getTimeBlockString(content)
       if (thisTimeStr !== '') {
-        endTimeStr = thisTimeStr.split('-')[1]
+        // Prefer ASCII hyphen; also accept en-dash / tilde separators used in some timeblocks
+        const endTimeStr = thisTimeStr.split(/[-–~]/)[1]
+        if (!endTimeStr) {
+          return { hours: NaN, mins: NaN }
+        }
+        // Note: split with RE_AMPM_OPT as a string (same as getStartTimeObjFromParaContent) - not as RegExp,
+        // because the optional group would match empty strings and shred the time.
         const [timeStr, ampm] = endTimeStr.split(RE_AMPM_OPT)
         if (timeStr.includes(':')) {
           ;[hours, mins] = timeStr.split(':').map(Number)
         } else {
           hours = Number(timeStr)
+          mins = 0
         }
-        if (ampm.toLowerCase() === 'pm' && hours !== 12) {
+        if (ampm && ampm.toLowerCase() === 'pm' && hours !== 12) {
           hours += 12
-        } else if (ampm.toLowerCase() === 'am' && hours === 12) {
+        } else if (ampm && ampm.toLowerCase() === 'am' && hours === 12) {
           hours = 0
         }
         logDebug('getEndTimeObjFromParaContent', `timeStr = ${endTimeStr} from timeblock ${thisTimeStr}`)
       }
     }
-    const startTime = { hours: hours, mins: mins }
-    return startTime
+    return { hours: hours, mins: mins }
   } catch (error) {
     logError('getEndTimeObjFromParaContent', `${JSP(error)}`)
     return { hours: NaN, mins: NaN }
@@ -525,3 +594,65 @@ export function getTimeBlockDetails(content: string, timeblockTextMustContainStr
     return ['', ''] // Return an empty tuple as a fallback
   }
 }
+
+/**
+ * Strip the timeblock string and optional NotePlan "Text must contain" marker from paragraph content.
+ * Also collapses leftover whitespace.
+ * @param {string} content - paragraph content that may include a timeblock
+ * @param {string} timeblockMustContainString - NotePlan preference string that may be empty
+ * @returns {string} content with timeblock (and must-contain marker) removed
+ */
+export function stripTimeBlockAndMustContainFromContent(content: string, timeblockMustContainString: string = ''): string {
+  try {
+    if (!content) return ''
+    const timeBlockString = getTimeBlockString(content)
+    let cleaned = content
+    if (timeBlockString !== '') {
+      // Remove the timeblock itself
+      cleaned = cleaned.replace(timeBlockString, '')
+    }
+    // then the must-contain string
+    if (timeblockMustContainString !== '') {
+      cleaned = cleaned.replace(timeblockMustContainString, '')
+    }
+    return cleaned.replace(/\s{2,}/g, ' ').trim()
+  } catch (err) {
+    logError('stripTimeBlockAndMustContainFromContent', err.message)
+    return content ?? ''
+  }
+}
+
+/**
+ * Build a display time label from dashboard para startTime/endTime (already normalised HH:mm).
+ * @param {?string} startTime - e.g. '10:00', or 'none'/empty if absent
+ * @param {?string} endTime - e.g. '16:30', or absent when there is no end
+ * @returns {string} e.g. '10:00-16:30', '10:00', or ''
+ */
+export function formatTimeBlockLabelFromStartAndEnd(startTime: ?string, endTime: ?string): string {
+  if (!startTime || startTime === 'none') return ''
+  if (endTime && endTime !== 'none') {
+    return `${startTime}-${endTime}`
+  }
+  return startTime
+}
+
+/**
+ * Prepare timeblock content for display with the time always at the start.
+ * Strips the original timeblock and "Text must contain" marker from content, and builds a leading
+ * time label from the para's startTime/endTime fields.
+ * @param {string} content - original paragraph content
+ * @param {?string} startTime - normalised start from TParagraphForDashboard
+ * @param {?string} endTime - normalised end from TParagraphForDashboard (optional)
+ * @param {string} timeblockMustContainString - NotePlan preference string that may be empty
+ * @returns {{ timeLabel: string, restContent: string }}
+ */
+export function prepareTimeBlockContentForDisplay(
+  content: string,
+  startTime: ?string,
+  endTime: ?string,
+  timeblockMustContainString: string = '',
+): { timeLabel: string, restContent: string } {
+  const timeLabel = formatTimeBlockLabelFromStartAndEnd(startTime, endTime)
+  const restContent = stripTimeBlockAndMustContainFromContent(content, timeblockMustContainString)
+  return { timeLabel, restContent }
+}

jgclark.Dashboard/CHANGELOG.md

@@ -15,7 +15,7 @@ For more details see the [plugin's documentation](https://github.com/NotePlan/pl
   - Added workarounds for newly-discovered NP API bugs/quirks for reading/writing Reminders.
   - When Reminders section is enabled, the **Current time block** section is titled **Timed Items**, and timed reminders only appear there once their due time has been reached.
 - The "Current Time block" section is now titled just "Time Block" when Reminders are turned off.
-- Time displays on timeblock and reminder items now use a neater lozenge with a clock icon at the start.
+- Time displays on timeblock and reminder items now use a neater lozenge with a clock icon, always placed at the start of the line (original mid-line timeblock and NotePlan "Text must contain" marker are stripped from the remaining text).
 - Scheduled `>date` markers on items are now shown in a neater lozenge with a calendar icon at the start.
 - Note context links (`ItemNoteLink`) now use a tint-colored lozenge with border and smaller text, wrapping teamspace, folder, and note title while keeping their existing icons and colors.
 - Removed beta feature flag item "Show Banner Test Buttons".