TaskSorting-v1.3.1 fix for Tags and mentions containing accented, non-Latin or symbol characters

Author: dwertheimer

dwertheimer.TaskSorting/CHANGELOG.md

@@ -4,6 +4,14 @@
 
 See Plugin [README](https://github.com/NotePlan/plugins/blob/main/dwertheimer.TaskSorting/README.md) for details on available commands and use case.
 
+## [1.3.1] - 2026-08-11 (@dwertheimer)
+
+### Fixed
+- **Tags and mentions containing accented, non-Latin or symbol characters were truncated when sorting** ([#776](https://github.com/NotePlan/plugins/issues/776)). The tag-matching regex only accepted `a-z`, `A-Z`, `0-9` and `/`, so `#Führung` was read as the tag `F` — which sorted wrongly and produced a `#### #F:` heading when *Include Primary Sort Key Heading in Output?* was on.
+- Tag and mention matching now follows the same rule NotePlan itself uses, verified case by case against the app's own `paragraph.hashtags` / `paragraph.mentions`: letters, combining marks and digits of **any** script, plus **any** Unicode symbol (`$ + = ~ ^ < | € £ ° →` and emoji), plus the three punctuation exceptions `-`, `_` and `/`. Every other punctuation character (`. , % & ' ! ? : ; ( ) [ ] { } * @ " \ #`) and any whitespace ends the tag, so ordinary sentence punctuation is not swallowed (`#shopping.` still sorts as `shopping`).
+- Consequences of the above, all matching NotePlan: `#my-tag` now sorts as `my-tag` rather than `my`; a trailing slash is trimmed (`#tag/` → `tag`); and a tag that is only digits and dashes (`#123`, `#2024-05`) is correctly not treated as a tag at all.
+- Mentions get the same treatment (`@Müller` no longer becomes `@M`). As in NotePlan, the trailing `(...)` is not part of the mention, so `@estimate(2)` and `@estimate(5)` still sort together under `@estimate`.
+
 ## [1.3.0] - 2026-08-02 (@dwertheimer)
 
 ### Fixed

dwertheimer.TaskSorting/plugin.json

@@ -3,7 +3,7 @@
   "noteplan.minAppVersion": "3.4.0",
   "plugin.id": "dwertheimer.TaskSorting",
   "plugin.name": "🥷 Task Sorting & Tools",
-  "plugin.version": "1.3.0",
+  "plugin.version": "1.3.1",
   "plugin.lastUpdateInfo": "1.3.0: Indented subtasks are no longer flattened when sorting -- a task now keeps its whole nested subtree, at every depth. 'Sort tasks under heading' now respects the 'Combine Related Task Types?' setting (it was previously ignored by that command). NOTE: indent with TABS -- NotePlan does not report space-indentation to plugins, so space-indented subtasks cannot be preserved.",
   "plugin.description": "Commands for sorting tasks in a note",
   "plugin.releaseStatus": "",

helpers/__tests__/sorting.test.js

@@ -484,6 +484,76 @@ describe('sorting.js', () => {
       const result = s.getSortableTask(paragraph)
       expect(result).toHaveProperty('mentions', ['foo'])
     })
+    /**
+     * Tag/mention character set (issue #776).
+     * Every expectation below was read back from NotePlan's OWN parser (paragraph.hashtags /
+     * paragraph.mentions) on a probe note, so these lock our regex to the app's behaviour.
+     * The rule: letters/marks/digits of any script + any Unicode symbol + the three punctuation
+     * exceptions - _ / ; every other punctuation character and whitespace ends the tag.
+     */
+    describe('hashtag/mention character set (issue #776)', () => {
+      const hashtagsOf = (content) => s.getSortableTask(new Paragraph({ type: 'open', content, filename: 'testFile.md' })).hashtags
+      const mentionsOf = (content) => s.getSortableTask(new Paragraph({ type: 'open', content, filename: 'testFile.md' })).mentions
+
+      test('should keep accented characters in a hashtag (the reported bug)', () => {
+        expect(hashtagsOf('!!! #Führen #Roadmap → Priorisierung 1')).toEqual(['Führen', 'Roadmap'])
+      })
+      test('should keep non-Latin scripts, combining marks and emoji in a hashtag', () => {
+        expect(hashtagsOf('test #日本語 #Ålesund #café #a😀b')).toEqual(['日本語', 'Ålesund', 'café', 'a😀b'])
+      })
+      test('should keep the - _ / punctuation exceptions', () => {
+        expect(hashtagsOf('test #a-b #c_d #tag/sub #a/b/c #-lead #_lead #trail-')).toEqual(['a-b', 'c_d', 'tag/sub', 'a/b/c', '-lead', '_lead', 'trail-'])
+      })
+      test('should keep Unicode symbols ($ + = ~ ^ < | and currency)', () => {
+        expect(hashtagsOf('test #a$b #a+b #a=b #a~b #a^b #a<b #a|b #a€b #a£b #a°b #a→b')).toEqual([
+          'a$b',
+          'a+b',
+          'a=b',
+          'a~b',
+          'a^b',
+          'a<b',
+          'a|b',
+          'a€b',
+          'a£b',
+          'a°b',
+          'a→b',
+        ])
+      })
+      test('should stop at any other punctuation character', () => {
+        expect(hashtagsOf(`#a.b #a,b #a%b #a&b #a'b #a!b #a?b #a:b #a;b #a(b #a[b #a*b #a@b #a"b #a{b`)).toEqual(Array(15).fill('a'))
+      })
+      test('should trim trailing sentence punctuation', () => {
+        expect(hashtagsOf('buy milk #shopping. and #errands, and #chores)')).toEqual(['shopping', 'errands', 'chores'])
+      })
+      test('should trim a trailing slash', () => {
+        expect(hashtagsOf('test #tag/')).toEqual(['tag'])
+      })
+      test('should keep a multi-level tag as one full path, not split into levels', () => {
+        // Deliberate: NotePlan's own paragraph.hashtags returns every level (["#a", "#a/b", "#a/b/c"]),
+        // but the sort key is hashtags[0], so emitting parents would collapse all "#project/*" tasks into
+        // a single "#project" group. Full paths still sort adjacently and in tree order.
+        expect(hashtagsOf('test #project/alpha')).toEqual(['project/alpha'])
+        const tasks = ['#work', '#project/beta', '#project/alpha', '#project', '#zebra'].map((tag) => hashtagsOf(`task ${tag}`)[0])
+        expect([...tasks].sort()).toEqual(['project', 'project/alpha', 'project/beta', 'work', 'zebra'])
+      })
+      test('should not treat a digits-only tag as a hashtag', () => {
+        expect(hashtagsOf('test #123 #2024-05 #foo2 #a1b2')).toEqual(['foo2', 'a1b2'])
+      })
+      test('should not treat a # in the middle of a word as a hashtag', () => {
+        expect(hashtagsOf('word#nottag')).toEqual([])
+      })
+      test('should find a hashtag wrapped in parentheses', () => {
+        expect(hashtagsOf('(#parens) done')).toEqual(['parens'])
+      })
+      test('should apply the same rules to mentions', () => {
+        expect(mentionsOf('test @Müller @a-b @a_b @a/b @a$b @日本語')).toEqual(['Müller', 'a-b', 'a_b', 'a/b', 'a$b', '日本語'])
+        expect(mentionsOf('test @a.b @a%b')).toEqual(['a', 'a'])
+        expect(mentionsOf('test @123')).toEqual([])
+      })
+      test('should drop the parenthetical part of a mention, as NotePlan does, so siblings group together', () => {
+        expect(mentionsOf('test @estimate(2) @done(2026-08-11)')).toEqual(['estimate', 'done'])
+      })
+    })
     test('should not have exclamation mark priority', () => {
       const paragraph = new Paragraph({ type: 'open', content: 'test content !!!', filename: 'testFile.md' })
       const result = s.getSortableTask(paragraph)

helpers/sorting.js

@@ -52,8 +52,28 @@ export type GroupedTasks = {
 /** Sorted/grouped task buckets produced by TaskSorting (always SortableParagraphSubset elements). */
 export type ParagraphsGroupedByType = GroupedTasks
 
-const RE_HASHTAGS: RegExp = /\B#([a-zA-Z0-9\/]+\b)/g
-const RE_MENTIONS: RegExp = /\B@([a-zA-Z0-9\/]+\b)/g
+// Tag/mention matching, deliberately mirroring how NotePlan itself parses `paragraph.hashtags` /
+// `paragraph.mentions`, so that sorting groups tasks under the same tag the app shows on the line.
+// The rule (verified against NotePlan's own parser) is: a tag may contain letters, combining marks and
+// digits of ANY script, plus ANY Unicode symbol ($ + = ~ ^ < | € £ ° → and emoji), plus the three
+// punctuation exceptions - _ / . Every other punctuation character (. , % & ' ! ? : ; ( ) [ ] { } * @ " \ #)
+// and any whitespace ends the tag.
+// The old class was /[a-zA-Z0-9\/]+/, which truncated "#Führung" to "F" (see issue #776).
+// Details:
+// - leading (?!...) drops tags that are only digits/-/_//, so "#123" and "#2024-05" are not tags, as in NotePlan
+// - the final character class excludes "/" so a trailing slash is trimmed ("#tag/" -> "tag"), again as in NotePlan
+// - no trailing \b: it is ASCII-only, so a tag ending in a non-ASCII character would backtrack to a truncated match
+//
+// Multi-level tags: we return the FULL path as a single value ("#project/alpha" -> "project/alpha"), which is
+// how this helper has behaved since 2022. Note that NotePlan's own `paragraph.hashtags` instead returns every
+// level ("#a/b/c" -> ["#a", "#a/b", "#a/b/c"]); we deliberately do not do that here, because the sort key is
+// `hashtags[0]` (see firstValue()), so emitting parents would collapse every "#project/*" task into one
+// "#project" group. Keeping the full path still sorts siblings adjacently and in tree order, since the key is
+// a plain string -- so the hierarchy reads correctly without losing the distinction between the leaves.
+const RE_HASHTAGS: RegExp = /\B(?:#|＃)((?![\p{N}\-_\/]+(?:$|[^\p{L}\p{M}\p{N}\p{S}\-_\/]))[\p{L}\p{M}\p{N}\p{S}\-_\/]{0,59}[\p{L}\p{M}\p{N}\p{S}\-_])/gu
+// Mentions follow the same rule. NotePlan reports "@estimate(2)" as the mention "@estimate", so the
+// trailing "(...)" is left out here too -- which also keeps @estimate(2) and @estimate(5) in one sort group.
+const RE_MENTIONS: RegExp = /\B@((?![\p{N}\-_\/]+(?:$|[^\p{L}\p{M}\p{N}\p{S}\-_\/]))[\p{L}\p{M}\p{N}\p{S}\-_\/]{0,59}[\p{L}\p{M}\p{N}\p{S}\-_])/gu
 const RE_LEADING_EXCLAMATIONS: RegExp = /^\s*(!+)/g // at start of content, though allowing for leading whitespace (as NP does)
 const RE_LEADING_PARENS_PRIORITY: RegExp = /^\s*\(([a-zA-z])\)\B/g // must be at start of content
 export const TASK_TYPES: Array<string> = ['open', 'scheduled', 'done', 'cancelled', 'checklist', 'checklistDone', 'checklistCancelled', 'checklistScheduled']