= {
41 | automaticBookmarksIntegration: true,
42 | bookmarksContextMenus: true
43 | }
44 |
45 | const pathToFlatString = (path: string): string => {
46 | return path.replace(/\//g,'_').replace(/\\/g, '_')
47 | }
48 |
49 | export class CustomSortSettingTab extends PluginSettingTab {
50 | plugin: CustomSortPlugin;
51 |
52 | constructor(app: App, plugin: CustomSortPlugin) {
53 | super(app, plugin);
54 | this.plugin = plugin;
55 | }
56 |
57 | display(): void {
58 | const {containerEl} = this;
59 |
60 | containerEl.empty();
61 |
62 | const delayDescr: DocumentFragment = sanitizeHTMLToDom(
63 | 'Number of seconds to wait before applying custom ordering on plugin / app start.'
64 | + '
'
65 | + 'For large vaults, multi-plugin vaults or on mobile the value might need to be increased if you encounter issues with auto-applying'
66 | + ' of custom ordering on start. The delay gives Obsidian additional time to sync notes from cloud storages, to populate notes metadata caches,'
67 | + ' etc.'
68 | + '
'
69 | + 'At the same time if your vault is relatively small or only used on desktop, or not synced with other copies,'
70 | + ' decreasing the delay to 0 could be a safe option.'
71 | + '
'
72 | + `Min: ${DELAY_MIN_SECONDS} sec., max. ${DELAY_MAX_SECONDS} sec.`
73 | )
74 |
75 | new Setting(containerEl)
76 | .setName('Delay for initial automatic application of custom ordering')
77 | .setDesc(delayDescr)
78 | .addText(text => text
79 | .setValue(`${this.plugin.settings.delayForInitialApplication/MILIS}`)
80 | .onChange(async (value) => {
81 | let delayS = parseFloat(value)
82 | delayS = (Number.isNaN(delayS) || !Number.isFinite((delayS))) ? DEFAULT_DELAY_SECONDS : (delayS < DELAY_MIN_SECONDS ? DELAY_MIN_SECONDS :(delayS > DELAY_MAX_SECONDS ? DELAY_MAX_SECONDS : delayS))
83 | delayS = Math.round(delayS*10) / 10 // allow values like 0.2
84 | this.plugin.settings.delayForInitialApplication = delayS * MILIS
85 | await this.plugin.saveSettings()
86 | }))
87 |
88 | const additionalSortspecFileDescr: DocumentFragment = sanitizeHTMLToDom(
89 | 'A note name or note path to scan (YAML frontmatter) for sorting specification in addition to the `sortspec` notes and Folder Notes.'
90 | + '
'
91 | + ' The `.md` filename suffix is optional.'
92 | + '
'
93 | + 'NOTE: After updating this setting remember to refresh the custom sorting via clicking on the ribbon icon or via the sort-on command'
94 | + ' or by restarting Obsidian or reloading the vault
'
95 | )
96 |
97 | new Setting(containerEl)
98 | .setName('Path or name of additional note(s) containing sorting specification')
99 | .setDesc(additionalSortspecFileDescr)
100 | .addText(text => text
101 | .setPlaceholder('e.g. sorting-configuration')
102 | .setValue(this.plugin.settings.additionalSortspecFile)
103 | .onChange(async (value) => {
104 | this.plugin.settings.additionalSortspecFile = value.trim() ? normalizePath(value) : '';
105 | await this.plugin.saveSettings();
106 | }));
107 |
108 | const indexNoteNameDescr: DocumentFragment = sanitizeHTMLToDom(
109 | 'If you employ the Index-File based approach to folder notes (as documented in '
110 | + 'Aidenlx Folder Note preferences'
112 | + ') enter here the index note name, e.g. _about_ or index'
113 | + '
'
114 | + ' The `.md` filename suffix is optional.'
115 | + '
'
116 | + 'This will tell the plugin to read sorting specs and also folders metadata from these files.'
117 | + '
'
118 | + 'The Inside Folder, with Same Name Recommended mode of Folder Notes is handled automatically, no additional configuration needed.'
119 | + ''
120 | + 'NOTE: After updating this setting remember to refresh the custom sorting via clicking on the ribbon icon or via the sort-on command'
121 | + ' or by restarting Obsidian or reloading the vault
'
122 | )
123 |
124 | new Setting(containerEl)
125 | .setName('Name of index note (Folder Notes support)')
126 | .setDesc(indexNoteNameDescr)
127 | .addText(text => text
128 | .setPlaceholder('e.g. _about_ or index')
129 | .setValue(this.plugin.settings.indexNoteNameForFolderNotes)
130 | .onChange(async (value) => {
131 | this.plugin.settings.indexNoteNameForFolderNotes = value.trim() ? normalizePath(value) : '';
132 | await this.plugin.saveSettings();
133 | }));
134 |
135 | new Setting(containerEl)
136 | .setName('Enable the status bar entry')
137 | .setDesc('The status bar entry shows the label `Custom sort:ON` or `Custom sort:OFF`, representing the current state of the plugin.')
138 | .addToggle(toggle => toggle
139 | .setValue(this.plugin.settings.statusBarEntryEnabled)
140 | .onChange(async (value) => {
141 | this.plugin.settings.statusBarEntryEnabled = value;
142 | if (value) {
143 | // Enabling
144 | if (this.plugin.statusBarItemEl) {
145 | // for sanity
146 | this.plugin.statusBarItemEl.detach()
147 | }
148 | this.plugin.statusBarItemEl = this.plugin.addStatusBarItem();
149 | this.plugin.updateStatusBar()
150 |
151 | } else { // disabling
152 | if (this.plugin.statusBarItemEl) {
153 | this.plugin.statusBarItemEl.detach()
154 | }
155 | }
156 | await this.plugin.saveSettings();
157 | }));
158 |
159 | new Setting(containerEl)
160 | .setName('Enable notifications of plugin state changes')
161 | .setDesc('The plugin can show notifications about its state changes: e.g. when successfully parsed and applied'
162 | + ' the custom sorting specification, or, when the parsing failed. If the notifications are disabled,'
163 | + ' the only indicator of plugin state is the ribbon button icon. The developer console presents the parsing'
164 | + ' error messages regardless if the notifications are enabled or not.')
165 | .addToggle(toggle => toggle
166 | .setValue(this.plugin.settings.notificationsEnabled)
167 | .onChange(async (value) => {
168 | this.plugin.settings.notificationsEnabled = value;
169 | await this.plugin.saveSettings();
170 | }));
171 |
172 | new Setting(containerEl)
173 | .setName('Enable notifications of plugin state changes for mobile devices only')
174 | .setDesc('See above.')
175 | .addToggle(toggle => toggle
176 | .setValue(this.plugin.settings.mobileNotificationsEnabled)
177 | .onChange(async (value) => {
178 | this.plugin.settings.mobileNotificationsEnabled = value;
179 | await this.plugin.saveSettings();
180 | }));
181 |
182 | new Setting(containerEl)
183 | .setName('Enable File Explorer context submenu`Custom sort:`')
184 | .setDesc('Gives access to operations relevant for custom sorting, e.g. applying custom sorting.')
185 | .addToggle(toggle => toggle
186 | .setValue(this.plugin.settings.customSortContextSubmenu)
187 | .onChange(async (value) => {
188 | this.plugin.settings.customSortContextSubmenu = value;
189 | await this.plugin.saveSettings();
190 | }));
191 |
192 | containerEl.createEl('h2', {text: 'Bookmarks integration'});
193 | const bookmarksIntegrationDescription: DocumentFragment = sanitizeHTMLToDom(
194 | 'If enabled, order of files and folders in File Explorer will reflect the order '
195 | + 'of bookmarked items in the bookmarks (core plugin) view. Automatically, without any '
196 | + 'need for sorting configuration. At the same time, it integrates seamlessly with'
197 | + ' sorting-spec:
configurations and they can nicely cooperate.'
198 | + '
'
199 | + 'To separate regular bookmarks from the bookmarks created for sorting, you can put '
200 | + 'the latter in a separate dedicated bookmarks group. The default name of the group is '
201 | + "'" + DEFAULT_SETTINGS.bookmarksGroupToConsumeAsOrderingReference + "' "
202 | + 'and you can change the group name in the configuration field below.'
203 | + '
'
204 | + 'If left empty, all the bookmarked items will be used to impose the order in File Explorer.
'
205 | + 'More information on this functionality in the '
206 | + ''
207 | + 'manual of this custom-sort plugin.'
208 | + '
'
209 | )
210 |
211 | new Setting(containerEl)
212 | .setName('Automatic integration with core Bookmarks plugin (for indirect drag & drop ordering)')
213 | .setDesc(bookmarksIntegrationDescription)
214 | .addToggle(toggle => toggle
215 | .setValue(this.plugin.settings.automaticBookmarksIntegration)
216 | .onChange(async (value) => {
217 | this.plugin.settings.automaticBookmarksIntegration = value;
218 | await this.plugin.saveSettings();
219 | }));
220 |
221 | new Setting(containerEl)
222 | .setName('Name of the group in Bookmarks from which to read the order of items')
223 | .setDesc('See above.')
224 | .addText(text => text
225 | .setPlaceholder('e.g. Group for sorting')
226 | .setValue(this.plugin.settings.bookmarksGroupToConsumeAsOrderingReference)
227 | .onChange(async (value) => {
228 | value = groupNameForPath(value.trim()).trim()
229 | this.plugin.settings.bookmarksGroupToConsumeAsOrderingReference = value ? pathToFlatString(normalizePath(value)) : '';
230 | await this.plugin.saveSettings();
231 | }));
232 |
233 | const bookmarksIntegrationContextMenusDescription: DocumentFragment = sanitizeHTMLToDom(
234 | 'Enable Custom-sort: bookmark for sorting and Custom-sort: bookmark+siblings for sorting (and related) entries '
235 | + 'in context menu in File Explorer'
236 | )
237 | new Setting(containerEl)
238 | .setName('Context menus for Bookmarks integration')
239 | .setDesc(bookmarksIntegrationContextMenusDescription)
240 | .addToggle(toggle => toggle
241 | .setValue(this.plugin.settings.bookmarksContextMenus)
242 | .onChange(async (value) => {
243 | this.plugin.settings.bookmarksContextMenus = value;
244 | if (value) {
245 | this.plugin.settings.customSortContextSubmenu = true; // automatically enable custom sort context submenu
246 | }
247 | await this.plugin.saveSettings();
248 | }))
249 | }
250 | }
251 |
--------------------------------------------------------------------------------
/src/test/int/dates-in-names.int.test.ts:
--------------------------------------------------------------------------------
1 | import {
2 | TAbstractFile, TFile,
3 | TFolder,
4 | Vault
5 | } from "obsidian";
6 | import {
7 | DEFAULT_FOLDER_CTIME,
8 | determineFolderDatesIfNeeded,
9 | determineSortingGroup,
10 | FolderItemForSorting,
11 | OS_alphabetical,
12 | OS_byCreatedTime,
13 | ProcessingContext,
14 | sortFolderItems
15 | } from "../../custom-sort/custom-sort";
16 | import {
17 | CustomSortGroupType,
18 | CustomSortOrder,
19 | CustomSortSpec
20 | } from "../../custom-sort/custom-sort-types";
21 | import {
22 | TIMESTAMP_OLDEST,
23 | TIMESTAMP_NEWEST,
24 | mockTFolderWithChildren,
25 | mockTFolderWithDateNamedChildren,
26 | TIMESTAMP_DEEP_NEWEST,
27 | TIMESTAMP_DEEP_OLDEST,
28 | mockTFolderWithDateWeekNamedChildrenForISOvsUSweekNumberingTest,
29 | mockTFolderWithDateWeekNamedChildren, mockTFile, mockTFolder,
30 | } from "../mocks";
31 | import {
32 | SortingSpecProcessor
33 | } from "../../custom-sort/sorting-spec-processor";
34 |
35 | describe('sortFolderItems', () => {
36 | it('should correctly handle Mmm-dd-yyyy pattern in file and folder names', () => {
37 | // given
38 | const processor: SortingSpecProcessor = new SortingSpecProcessor()
39 | const sortSpecTxt =
40 | `
41 | ... \\[Mmm-dd-yyyy]
42 | > a-z
43 | `
44 | const PARENT_PATH = 'parent/folder/path'
45 | const sortSpecsCollection = processor.parseSortSpecFromText(
46 | sortSpecTxt.split('\n'),
47 | PARENT_PATH,
48 | 'file name with the sorting, irrelevant here'
49 | )
50 |
51 | const folder: TFolder = mockTFolderWithDateNamedChildren(PARENT_PATH)
52 | const sortSpec: CustomSortSpec = sortSpecsCollection?.sortSpecByPath![PARENT_PATH]!
53 |
54 | const ctx: ProcessingContext = {}
55 |
56 | // when
57 | const result: Array = sortFolderItems(folder, folder.children, sortSpec, ctx, OS_alphabetical)
58 |
59 | // then
60 | const orderedNames = result.map(f => f.name)
61 | expect(orderedNames).toEqual([
62 | 'CCC Feb-28-2025',
63 | 'BBB Dec-23-2024.md',
64 | 'DDD Jul-15-2024.md',
65 | 'AAA Jan-01-2012'
66 | ])
67 | })
68 | it('should correctly handle yyyy-Www (mm-dd) pattern in file and folder names', () => {
69 | // given
70 | const processor: SortingSpecProcessor = new SortingSpecProcessor()
71 | const sortSpecTxt =
72 | `
73 | ... \\[yyyy-Www (mm-dd)]
74 | < a-z
75 | ------
76 | `
77 | const PARENT_PATH = 'parent/folder/path'
78 | const sortSpecsCollection = processor.parseSortSpecFromText(
79 | sortSpecTxt.split('\n'),
80 | PARENT_PATH,
81 | 'file name with the sorting, irrelevant here'
82 | )
83 |
84 | const folder: TFolder = mockTFolderWithDateWeekNamedChildren(PARENT_PATH)
85 | const sortSpec: CustomSortSpec = sortSpecsCollection?.sortSpecByPath![PARENT_PATH]!
86 |
87 | const ctx: ProcessingContext = {}
88 |
89 | // when
90 | const result: Array = sortFolderItems(folder, folder.children, sortSpec, ctx, OS_alphabetical)
91 |
92 | // then
93 | const orderedNames = result.map(f => f.name)
94 | expect(orderedNames).toEqual([
95 | "GHI 2021-W1 (01-04)",
96 | "DEF 2021-W9 (03-01).md",
97 | "ABC 2021-W13 (03-29)",
98 | "MNO 2021-W45 (11-08).md",
99 | "JKL 2021-W52 (12-27).md",
100 | "------.md"
101 | ])
102 | })
103 | it('should correctly handle yyyy-WwwISO pattern in file and folder names', () => {
104 | // given
105 | const processor: SortingSpecProcessor = new SortingSpecProcessor()
106 | const sortSpecTxt =
107 | `
108 | /+ ... \\[yyyy-Www (mm-dd)]
109 | /+ ... \\[yyyy-WwwISO]
110 | < a-z
111 | `
112 | const PARENT_PATH = 'parent/folder/path'
113 | const sortSpecsCollection = processor.parseSortSpecFromText(
114 | sortSpecTxt.split('\n'),
115 | PARENT_PATH,
116 | 'file name with the sorting, irrelevant here'
117 | )
118 |
119 | const folder: TFolder = mockTFolderWithDateWeekNamedChildrenForISOvsUSweekNumberingTest(PARENT_PATH)
120 | const sortSpec: CustomSortSpec = sortSpecsCollection?.sortSpecByPath![PARENT_PATH]!
121 |
122 | const ctx: ProcessingContext = {}
123 |
124 | // when
125 | const result: Array = sortFolderItems(folder, folder.children, sortSpec, ctx, OS_alphabetical)
126 |
127 | // then
128 | // ISO standard of weeks numbering
129 | const orderedNames = result.map(f => f.name)
130 | expect(orderedNames).toEqual([
131 | 'E 2021-W1 (01-01)',
132 | 'F ISO:2021-01-04 US:2020-12-28 2021-W1',
133 | 'A 2021-W10 (03-05).md',
134 | 'B ISO:2021-03-08 US:2021-03-01 2021-W10',
135 | 'C 2021-W51 (12-17).md',
136 | 'D ISO:2021-12-20 US:2021-12-13 2021-W51.md',
137 | 'FFF2 ISO:2021-12-27 US:2021-12-20 2021-W52.md',
138 | 'FFF1 ISO:2022-01-03 US:2021-12-27 2021-W53.md',
139 | "------.md"
140 | ])
141 | })
142 | it('should correctly handle yyyy-Www pattern in file and folder names', () => {
143 | // given
144 | const processor: SortingSpecProcessor = new SortingSpecProcessor()
145 | const sortSpecTxt =
146 | `
147 | /+ ... \\[yyyy-Www (mm-dd)]
148 | /+ ... \\[yyyy-Www]
149 | > a-z
150 | ... \\-d+
151 | `
152 | const PARENT_PATH = 'parent/folder/path'
153 | const sortSpecsCollection = processor.parseSortSpecFromText(
154 | sortSpecTxt.split('\n'),
155 | PARENT_PATH,
156 | 'file name with the sorting, irrelevant here'
157 | )
158 |
159 | const folder: TFolder = mockTFolderWithDateWeekNamedChildrenForISOvsUSweekNumberingTest(PARENT_PATH)
160 | const sortSpec: CustomSortSpec = sortSpecsCollection?.sortSpecByPath![PARENT_PATH]!
161 |
162 | const ctx: ProcessingContext = {}
163 |
164 | // when
165 | const result: Array = sortFolderItems(folder, folder.children, sortSpec, ctx, OS_alphabetical)
166 |
167 | // then
168 | // U.S. standard of weeks numbering
169 | const orderedNames = result.map(f => f.name)
170 | expect(orderedNames).toEqual([
171 | 'FFF1 ISO:2022-01-03 US:2021-12-27 2021-W53.md',
172 | 'FFF2 ISO:2021-12-27 US:2021-12-20 2021-W52.md',
173 | 'C 2021-W51 (12-17).md',
174 | 'D ISO:2021-12-20 US:2021-12-13 2021-W51.md',
175 | 'A 2021-W10 (03-05).md',
176 | 'B ISO:2021-03-08 US:2021-03-01 2021-W10',
177 | 'E 2021-W1 (01-01)',
178 | 'F ISO:2021-01-04 US:2020-12-28 2021-W1',
179 | "------.md"
180 | ])
181 | })
182 | it('should correctly mix for sorting different date formats in file and folder names', () => {
183 | // given
184 | const processor: SortingSpecProcessor = new SortingSpecProcessor()
185 | const sortSpecTxt =
186 | `
187 | /+ ... \\[yyyy-Www (mm-dd)]
188 | /+ ... \\[yyyy-Www]
189 | /+ ... mm-dd \\[yyyy-mm-dd]
190 | /+ ... dd-mm \\[yyyy-dd-mm]
191 | /+ ... \\[yyyy-mm-dd]
192 | /+ ... \\[Mmm-dd-yyyy]
193 | /+ \\[dd-Mmm-yyyy] ...
194 | > a-z
195 | `
196 | const PARENT_PATH = 'parent/folder/path'
197 | const sortSpecsCollection = processor.parseSortSpecFromText(
198 | sortSpecTxt.split('\n'),
199 | PARENT_PATH,
200 | 'file name with the sorting, irrelevant here'
201 | )
202 |
203 | const folder: TFolder = mockTFolderWithDateWeekNamedChildrenForISOvsUSweekNumberingTest(PARENT_PATH)
204 | folder.children.push(...[
205 | mockTFile('File 2021-12-14', 'md'),
206 | mockTFile('File mm-dd 2020-12-30', 'md'), // mm-dd
207 | mockTFile('File dd-mm 2020-31-12', 'md'), // dd-mm
208 | mockTFile('File Mar-08-2021', 'md'),
209 | mockTFile('18-Dec-2021 file', 'md'),
210 | ])
211 |
212 | const sortSpec: CustomSortSpec = sortSpecsCollection?.sortSpecByPath![PARENT_PATH]!
213 |
214 | const ctx: ProcessingContext = {}
215 |
216 | // when
217 | const result: Array = sortFolderItems(folder, folder.children, sortSpec, ctx, OS_alphabetical)
218 |
219 | // then
220 | // U.S. standard of weeks numbering
221 | const orderedNames = result.map(f => f.name)
222 | expect(orderedNames).toEqual([
223 | 'FFF1 ISO:2022-01-03 US:2021-12-27 2021-W53.md',
224 | 'FFF2 ISO:2021-12-27 US:2021-12-20 2021-W52.md',
225 | "18-Dec-2021 file.md",
226 | 'C 2021-W51 (12-17).md',
227 | "File 2021-12-14.md",
228 | 'D ISO:2021-12-20 US:2021-12-13 2021-W51.md',
229 | "File Mar-08-2021.md",
230 | 'A 2021-W10 (03-05).md',
231 | 'B ISO:2021-03-08 US:2021-03-01 2021-W10',
232 | 'E 2021-W1 (01-01)',
233 | "File dd-mm 2020-31-12.md",
234 | "File mm-dd 2020-12-30.md",
235 | 'F ISO:2021-01-04 US:2020-12-28 2021-W1',
236 | "------.md"
237 | ])
238 | })
239 | it('should correctly order the week number with specifiers', () => {
240 | // given
241 | const processor: SortingSpecProcessor = new SortingSpecProcessor()
242 | const sortSpecTxt =
243 | `
244 | /+ \\[yyyy-Www]
245 | /+ \\[yyyy-mm-dd]
246 | > a-z
247 | `
248 | const PARENT_PATH = 'parent/folder/path'
249 | const sortSpecsCollection = processor.parseSortSpecFromText(
250 | sortSpecTxt.split('\n'),
251 | PARENT_PATH,
252 | 'file name with the sorting, irrelevant here'
253 | )
254 |
255 | const folder: TFolder = mockTFolder(PARENT_PATH,[
256 | // ISO and U.S. standard for 2025 give the same week numbers (remark for clarity)
257 | mockTFile('2025-03-09', 'md'), // sunday of W10
258 | mockTFile('2025-W11-', 'md'), // earlier than monday of W11
259 | mockTFile('2025-03-10', 'md'), // monday W11
260 | mockTFile('2025-W11', 'md'), // monday of W11
261 | mockTFile('2025-03-16', 'md'), // sunday W11
262 | mockTFile('2025-W11+', 'md'), // later than sunday W11 // expected
263 | mockTFile('2025-03-17', 'md'), // monday of W12
264 | ])
265 |
266 | const sortSpec: CustomSortSpec = sortSpecsCollection?.sortSpecByPath![PARENT_PATH]!
267 |
268 | const ctx: ProcessingContext = {}
269 |
270 | // when
271 | const result: Array = sortFolderItems(folder, folder.children, sortSpec, ctx, OS_alphabetical)
272 |
273 | // then
274 | // U.S. standard of weeks numbering
275 | const orderedNames = result.map(f => f.name)
276 | expect(orderedNames).toEqual([
277 | "2025-03-17.md",
278 | '2025-W11+.md',
279 | "2025-03-16.md",
280 | '2025-W11.md',
281 | "2025-03-10.md",
282 | "2025-W11-.md",
283 | "2025-03-09.md",
284 | ])
285 | })
286 | })
287 |
288 |
289 |
290 |
--------------------------------------------------------------------------------
/src/test/int/folder-dates.int.test.ts:
--------------------------------------------------------------------------------
1 | import {
2 | TAbstractFile,
3 | TFolder,
4 | Vault
5 | } from "obsidian";
6 | import {
7 | DEFAULT_FOLDER_CTIME,
8 | determineFolderDatesIfNeeded,
9 | determineSortingGroup,
10 | FolderItemForSorting
11 | } from "../../custom-sort/custom-sort";
12 | import {
13 | CustomSortGroupType,
14 | CustomSortOrder,
15 | CustomSortSpec
16 | } from "../../custom-sort/custom-sort-types";
17 | import {
18 | TIMESTAMP_OLDEST,
19 | TIMESTAMP_NEWEST,
20 | mockTFolderWithChildren, TIMESTAMP_DEEP_NEWEST, TIMESTAMP_DEEP_OLDEST
21 | } from "../mocks";
22 |
23 | describe('determineFolderDatesIfNeeded', () => {
24 | it('should not be triggered if not needed - sorting method does not require it', () => {
25 | // given
26 | const folder: TFolder = mockTFolderWithChildren('Test folder 1')
27 | const OUTSIDERS_GROUP_IDX = 0
28 | const sortSpec: CustomSortSpec = {
29 | targetFoldersPaths: ['/'],
30 | groups: [{
31 | type: CustomSortGroupType.Outsiders,
32 | sorting: { order: CustomSortOrder.alphabetical }
33 | }],
34 | outsidersGroupIdx: OUTSIDERS_GROUP_IDX
35 | }
36 |
37 | // when
38 | const result: FolderItemForSorting = determineSortingGroup(folder, sortSpec)
39 | determineFolderDatesIfNeeded([result], sortSpec)
40 |
41 | // then
42 | expect(result.ctime).toEqual(DEFAULT_FOLDER_CTIME)
43 | expect(result.mtime).toEqual(DEFAULT_FOLDER_CTIME)
44 | })
45 | it.each(
46 | [
47 | [CustomSortOrder.byCreatedTimeReverseAdvanced, undefined],
48 | [CustomSortOrder.byCreatedTimeAdvanced, undefined],
49 | [CustomSortOrder.byModifiedTimeAdvanced, undefined],
50 | [CustomSortOrder.byModifiedTimeReverseAdvanced, undefined],
51 | [CustomSortOrder.alphabetical, CustomSortOrder.byCreatedTimeReverseAdvanced],
52 | [CustomSortOrder.alphabetical, CustomSortOrder.byCreatedTimeAdvanced],
53 | [CustomSortOrder.alphabetical, CustomSortOrder.byModifiedTimeAdvanced],
54 | [CustomSortOrder.alphabetical, CustomSortOrder.byModifiedTimeReverseAdvanced],
55 | ])('should correctly determine dates, if triggered by %s under default %s (no deep orders requested)', (order: CustomSortOrder, folderOrder: CustomSortOrder | undefined) => {
56 | // given
57 | const folder: TFolder = mockTFolderWithChildren('Test folder 1')
58 | const OUTSIDERS_GROUP_IDX = 0
59 | const sortSpec: CustomSortSpec = {
60 | targetFoldersPaths: ['/'],
61 | defaultSorting: folderOrder ? { order: folderOrder } : undefined,
62 | groups: [{
63 | type: CustomSortGroupType.Outsiders,
64 | sorting: { order: order }
65 | }],
66 | outsidersGroupIdx: OUTSIDERS_GROUP_IDX
67 | }
68 |
69 | // when
70 | const result: FolderItemForSorting = determineSortingGroup(folder, sortSpec)
71 | determineFolderDatesIfNeeded([result], sortSpec)
72 |
73 | // then
74 | expect(result.ctime).toEqual(TIMESTAMP_OLDEST)
75 | expect(result.mtime).toEqual(TIMESTAMP_NEWEST)
76 | })
77 | it.each(
78 | [
79 | [CustomSortOrder.alphabetical, CustomSortOrder.byCreatedTimeReverseAdvancedRecursive],
80 | [CustomSortOrder.alphabetical, CustomSortOrder.byCreatedTimeAdvancedRecursive],
81 | [CustomSortOrder.alphabetical, CustomSortOrder.byModifiedTimeAdvancedRecursive],
82 | [CustomSortOrder.alphabetical, CustomSortOrder.byModifiedTimeReverseAdvancedRecursive],
83 | [CustomSortOrder.byCreatedTimeReverseAdvancedRecursive, CustomSortOrder.byCreatedTimeReverseAdvanced],
84 | [CustomSortOrder.byCreatedTimeAdvancedRecursive, CustomSortOrder.byCreatedTimeAdvanced],
85 | [CustomSortOrder.byModifiedTimeAdvancedRecursive, CustomSortOrder.byModifiedTimeAdvanced],
86 | [CustomSortOrder.byModifiedTimeReverseAdvancedRecursive, CustomSortOrder.byModifiedTimeReverseAdvanced],
87 | ])('should correctly determine dates, if triggered by %s under default %s (deep orders)', (order: CustomSortOrder, folderOrder: CustomSortOrder | undefined) => {
88 | // given
89 | const folder: TFolder = mockTFolderWithChildren('Test folder 1')
90 | const OUTSIDERS_GROUP_IDX = 0
91 | const sortSpec: CustomSortSpec = {
92 | targetFoldersPaths: ['/'],
93 | defaultSorting: folderOrder ? { order: folderOrder} : undefined,
94 | groups: [{
95 | type: CustomSortGroupType.Outsiders,
96 | sorting: { order: order }
97 | }],
98 | outsidersGroupIdx: OUTSIDERS_GROUP_IDX
99 | }
100 |
101 | // when
102 | const result: FolderItemForSorting = determineSortingGroup(folder, sortSpec)
103 | determineFolderDatesIfNeeded([result], sortSpec)
104 |
105 | // then
106 | expect(result.ctime).toEqual(TIMESTAMP_DEEP_OLDEST)
107 | expect(result.mtime).toEqual(TIMESTAMP_DEEP_NEWEST)
108 | })
109 | })
110 |
111 |
112 |
113 |
--------------------------------------------------------------------------------
/src/test/mocks.ts:
--------------------------------------------------------------------------------
1 | import {
2 | TFile,
3 | TFolder,
4 | Vault
5 | } from "obsidian";
6 | import {
7 | lastPathComponent
8 | } from "../utils/utils";
9 |
10 | export const mockTFile = (basename: string, ext: string, size?: number, ctime?: number, mtime?: number): TFile => {
11 | return {
12 | stat: {
13 | ctime: ctime ?? 0,
14 | mtime: mtime ?? 0,
15 | size: size ?? 0
16 | },
17 | basename: basename,
18 | extension: ext,
19 | vault: {} as Vault, // To satisfy TS typechecking
20 | path: `Some parent folder/${basename}.${ext}`,
21 | name: `${basename}.${ext}`,
22 | parent: {} as TFolder // To satisfy TS typechecking
23 | }
24 | }
25 |
26 | export const mockTFolder = (name: string, children?: Array, parent?: TFolder): TFolder => {
27 | return {
28 | isRoot(): boolean { return name === '/' },
29 | vault: {} as Vault, // To satisfy TS typechecking
30 | path: `${name}`,
31 | name: lastPathComponent(name),
32 | parent: parent ?? ({} as TFolder), // To satisfy TS typechecking
33 | children: children ?? []
34 | }
35 | }
36 |
37 | export const MOCK_TIMESTAMP: number = 1656417542418
38 | export const TIMESTAMP_OLDEST: number = MOCK_TIMESTAMP
39 | export const TIMESTAMP_DEEP_OLDEST: number = TIMESTAMP_OLDEST - 1000
40 | export const TIMESTAMP_NEWEST: number = MOCK_TIMESTAMP + 1000
41 | export const TIMESTAMP_DEEP_NEWEST: number = TIMESTAMP_NEWEST + 1000
42 | export const TIMESTAMP_INBETWEEN: number = MOCK_TIMESTAMP + 500
43 |
44 | export const mockTFolderWithChildren = (name: string): TFolder => {
45 | const subchild1: TFile = mockTFile('Sub-child file 1 created as deep oldest, modified recently', 'md', 100, TIMESTAMP_DEEP_OLDEST, TIMESTAMP_NEWEST)
46 | const subfolder1: TFolder = mockTFolder('Subfolder with deep-oldest child file', [subchild1])
47 |
48 | const subchild2: TFile = mockTFile('Sub-child file 1 created as deep newest, modified recently', 'md', 100, TIMESTAMP_OLDEST, TIMESTAMP_DEEP_NEWEST)
49 | const subfolder2: TFolder = mockTFolder('Subfolder with deep-newest child file', [subchild2])
50 |
51 | const child1: TFolder = mockTFolder('Section A')
52 | const child2: TFolder = mockTFolder('Section B')
53 | const child3: TFile = mockTFile('Child file 1 created as oldest, modified recently', 'md', 100, TIMESTAMP_OLDEST, TIMESTAMP_NEWEST)
54 | const child4: TFile = mockTFile('Child file 2 created as newest, not modified at all', 'md', 100, TIMESTAMP_NEWEST, TIMESTAMP_NEWEST)
55 | const child5: TFile = mockTFile('Child file 3 created inbetween, modified inbetween', 'md', 100, TIMESTAMP_INBETWEEN, TIMESTAMP_INBETWEEN)
56 |
57 | return mockTFolder(name, [child1, child2, child3, child4, child5, subfolder1, subfolder2])
58 | }
59 |
60 | export const mockTFolderWithDateNamedChildren = (name: string): TFolder => {
61 | const child1: TFolder = mockTFolder('AAA Jan-01-2012')
62 | const child2: TFile = mockTFile('BBB Dec-23-2024', 'md')
63 | const child3: TFolder = mockTFolder('CCC Feb-28-2025')
64 | const child4: TFile = mockTFile('DDD Jul-15-2024', 'md')
65 |
66 | return mockTFolder(name, [child1, child2, child3, child4])
67 | }
68 |
69 | export const mockTFolderWithDateWeekNamedChildren = (name: string): TFolder => {
70 | // Assume ISO week numbers
71 | const child0: TFile = mockTFile('------', 'md')
72 | const child1: TFolder = mockTFolder('ABC 2021-W13 (03-29)')
73 | const child2: TFile = mockTFile('DEF 2021-W9 (03-01)', 'md')
74 | const child3: TFolder = mockTFolder('GHI 2021-W1 (01-04)')
75 | const child4: TFile = mockTFile('JKL 2021-W52 (12-27)', 'md')
76 | const child5: TFile = mockTFile('MNO 2021-W45 (11-08)', 'md')
77 |
78 | return mockTFolder(name, [child0, child1, child2, child3, child4, child5])
79 | }
80 |
81 | export const mockTFolderWithDateWeekNamedChildrenForISOvsUSweekNumberingTest = (name: string): TFolder => {
82 | // Tricky to test handling of both ISO and U.S. weeks numbering.
83 | // Sample year with different week numbers in ISO vs. U.S. is 2021 with 1st Jan on Fri, ISO != U.S.
84 | // Plain files and folder names to match both week-only and week+date syntax
85 | // Their relative ordering depends on week numbering
86 | const child0: TFile = mockTFile('------', 'md')
87 | const child1: TFile = mockTFile('A 2021-W10 (03-05)', 'md') // Tue date, (ISO) week number invalid, ignored
88 | const child2: TFolder = mockTFolder('B ISO:2021-03-08 US:2021-03-01 2021-W10')
89 | const child3: TFile = mockTFile('C 2021-W51 (12-17)', 'md') // Tue date, (ISO) week number invalid, ignored
90 | const child4: TFile = mockTFile('D ISO:2021-12-20 US:2021-12-13 2021-W51', 'md')
91 | const child5: TFolder = mockTFolder('E 2021-W1 (01-01)') // Tue date, to (ISO) week number invalid, ignored
92 | const child6: TFolder = mockTFolder('F ISO:2021-01-04 US:2020-12-28 2021-W1')
93 | const child7: TFile = mockTFile('FFF2 ISO:2021-12-27 US:2021-12-20 2021-W52', 'md')
94 | const child8: TFile = mockTFile('FFF1 ISO:2022-01-03 US:2021-12-27 2021-W53', 'md') // Invalid week, should fall to next year
95 |
96 | return mockTFolder(name, [child0, child1, child2, child3, child4, child5, child6, child7, child8])
97 | }
98 |
--------------------------------------------------------------------------------
/src/test/unit/custom-sort-getComparator.spec.ts:
--------------------------------------------------------------------------------
1 | import {
2 | FolderItemForSorting,
3 | getComparator,
4 | OS_byCreatedTime,
5 | OS_byModifiedTime,
6 | OS_byModifiedTimeReverse, SortingLevelId
7 | } from '../../custom-sort/custom-sort';
8 | import * as CustomSortModule from '../../custom-sort/custom-sort';
9 | import {CustomSortGroupType, CustomSortOrder, CustomSortSpec} from '../../custom-sort/custom-sort-types';
10 |
11 | const MOCK_TIMESTAMP: number = 1656417542418
12 |
13 | const FlatLevelSortSpec: CustomSortSpec = {
14 | groups: [{ // Not relevant in unit test
15 | exactText: "Nothing",
16 | filesOnly: true,
17 | sorting: { order: CustomSortOrder.alphabetical, },
18 | type: CustomSortGroupType.ExactName
19 | },{ // prepared for unit test
20 | exactPrefix: "Fi",
21 | sorting: { order: CustomSortOrder.byMetadataFieldAlphabeticalReverse, },
22 | type: CustomSortGroupType.ExactPrefix
23 | },{ // Not relevant in unit test
24 | type: CustomSortGroupType.Outsiders,
25 | sorting: { order: CustomSortOrder.byCreatedTime },
26 | }],
27 | outsidersGroupIdx: 2,
28 | defaultSorting: { order: CustomSortOrder.byCreatedTime, },
29 | targetFoldersPaths: ['parent folder']
30 | }
31 |
32 | const MultiLevelSortSpecGroupLevel: CustomSortSpec = {
33 | groups: [{ // Not relevant in unit test
34 | exactText: "Nothing",
35 | filesOnly: true,
36 | sorting: { order: CustomSortOrder.alphabetical, },
37 | type: CustomSortGroupType.ExactName
38 | },{ // prepared for unit test
39 | exactPrefix: "Fi",
40 | sorting: { order: CustomSortOrder.byMetadataFieldAlphabeticalReverse, },
41 | secondarySorting: { order: CustomSortOrder.byMetadataFieldTrueAlphabetical, },
42 | type: CustomSortGroupType.ExactPrefix
43 | },{ // Not relevant in unit test
44 | type: CustomSortGroupType.Outsiders,
45 | sorting: { order: CustomSortOrder.byCreatedTime },
46 | }],
47 | outsidersGroupIdx: 2,
48 | defaultSorting: { order: CustomSortOrder.byCreatedTime, },
49 | targetFoldersPaths: ['parent folder']
50 | }
51 |
52 | const MultiLevelSortSpecTargetFolderLevel: CustomSortSpec = {
53 | groups: [{ // Not relevant in unit test
54 | exactText: "Nothing",
55 | filesOnly: true,
56 | sorting: { order: CustomSortOrder.alphabetical, },
57 | type: CustomSortGroupType.ExactName
58 | },{ // prepared for unit test
59 | exactPrefix: "Fi",
60 | sorting: { order: CustomSortOrder.byMetadataFieldAlphabeticalReverse, },
61 | type: CustomSortGroupType.ExactPrefix
62 | },{ // Not relevant in unit test
63 | type: CustomSortGroupType.Outsiders,
64 | sorting: { order: CustomSortOrder.byCreatedTime },
65 | }],
66 | outsidersGroupIdx: 2,
67 | defaultSorting: { order: CustomSortOrder.byCreatedTime, },
68 | defaultSecondarySorting: { order: CustomSortOrder.byMetadataFieldTrueAlphabeticalReverse, },
69 | targetFoldersPaths: ['parent folder']
70 | }
71 |
72 | const MultiLevelSortSpecAndTargetFolderLevel: CustomSortSpec = {
73 | groups: [{ // Not relevant in unit test
74 | exactText: "Nothing",
75 | filesOnly: true,
76 | sorting: { order: CustomSortOrder.alphabetical, },
77 | type: CustomSortGroupType.ExactName
78 | },{ // prepared for unit test
79 | exactPrefix: "Fi",
80 | sorting: { order: CustomSortOrder.byMetadataFieldAlphabetical, },
81 | secondarySorting: { order: CustomSortOrder.byMetadataFieldAlphabeticalReverse, },
82 | type: CustomSortGroupType.ExactPrefix
83 | },{ // Not relevant in unit test
84 | type: CustomSortGroupType.Outsiders,
85 | sorting: { order: CustomSortOrder.byCreatedTime },
86 | }],
87 | outsidersGroupIdx: 2,
88 | defaultSorting: { order: CustomSortOrder.byMetadataFieldTrueAlphabetical, },
89 | defaultSecondarySorting: { order: CustomSortOrder.byMetadataFieldTrueAlphabeticalReverse, },
90 | targetFoldersPaths: ['parent folder']
91 | }
92 |
93 | const A_GOES_FIRST: number = -1
94 | const B_GOES_FIRST: number = 1
95 | const AB_EQUAL: number = 0
96 |
97 | const BaseItemForSorting1: FolderItemForSorting = {
98 | groupIdx: 1,
99 | isFolder: false,
100 | sortString: "References",
101 | sortStringWithExt: "References.md",
102 | ctime: MOCK_TIMESTAMP + 222,
103 | mtime: MOCK_TIMESTAMP + 333,
104 | path: 'parent folder/References.md',
105 | metadataFieldValue: 'direct metadata on file, under default name',
106 | metadataFieldValueSecondary: 'only used if secondary sort by metadata is used',
107 | metadataFieldValueForDerived: 'only used if derived primary sort by metadata is used',
108 | metadataFieldValueForDerivedSecondary: 'only used if derived secondary sort by metadata is used'
109 | }
110 |
111 | function getBaseItemForSorting(overrides?: Partial): FolderItemForSorting {
112 | return Object.assign({}, BaseItemForSorting1, overrides)
113 | }
114 |
115 | describe('getComparator', () => {
116 | const sp = jest.spyOn(CustomSortModule, 'getSorterFnFor')
117 | const collatorCmp = jest.spyOn(CustomSortModule, 'CollatorCompare')
118 | beforeEach(() => {
119 | sp.mockClear()
120 | })
121 | describe('should correctly handle flat sorting spec', () => {
122 | const comparator = getComparator(FlatLevelSortSpec, OS_byModifiedTime)
123 | it( 'in simple case - group-level comparison succeeds', () => {
124 | const a = getBaseItemForSorting({
125 | metadataFieldValue: 'value X'
126 | })
127 | const b= getBaseItemForSorting({
128 | metadataFieldValue: 'value Y'
129 | })
130 | const result = comparator(a,b)
131 | expect(result).toBe(B_GOES_FIRST)
132 | expect(sp).toBeCalledTimes(1)
133 | expect(sp).toBeCalledWith(CustomSortOrder.byMetadataFieldAlphabeticalReverse, OS_byModifiedTime, SortingLevelId.forPrimary)
134 | })
135 | it( 'in simple case - group-level comparison fails, use folder-level', () => {
136 | const a = getBaseItemForSorting()
137 | const b= getBaseItemForSorting({
138 | ctime: a.ctime - 100
139 | })
140 | const result = Math.sign(comparator(a,b))
141 | expect(result).toBe(B_GOES_FIRST)
142 | expect(sp).toBeCalledTimes(2)
143 | expect(sp).toHaveBeenNthCalledWith(1, CustomSortOrder.byMetadataFieldAlphabeticalReverse, OS_byModifiedTime, SortingLevelId.forPrimary)
144 | expect(sp).toHaveBeenNthCalledWith(2, CustomSortOrder.byCreatedTime, OS_byModifiedTime, SortingLevelId.forDerivedPrimary)
145 | })
146 | it( 'in simple case - group-level comparison fails, folder-level fails, the last resort default comes into play - case A', () => {
147 | const a = getBaseItemForSorting({
148 | sortString: 'Second'
149 | })
150 | const b= getBaseItemForSorting({
151 | sortString: 'First'
152 | })
153 | const result = comparator(a,b)
154 | expect(result).toBe(B_GOES_FIRST)
155 | expect(sp).toBeCalledTimes(3)
156 | expect(sp).toHaveBeenNthCalledWith(1, CustomSortOrder.byMetadataFieldAlphabeticalReverse, OS_byModifiedTime, SortingLevelId.forPrimary)
157 | expect(sp).toHaveBeenNthCalledWith(2, CustomSortOrder.byCreatedTime, OS_byModifiedTime, SortingLevelId.forDerivedPrimary)
158 | expect(sp).toHaveBeenNthCalledWith(3, CustomSortOrder.default, undefined, SortingLevelId.forDefaultWhenUnspecified)
159 | })
160 | })
161 | describe('should correctly handle secondary sorting spec', () => {
162 | beforeEach(() => {
163 | sp.mockClear()
164 | })
165 | describe('at group level', () => {
166 | const comparator = getComparator(MultiLevelSortSpecGroupLevel, OS_byModifiedTimeReverse)
167 | it('in simple case - secondary sort comparison succeeds', () => {
168 | const a = getBaseItemForSorting({
169 | metadataFieldValueSecondary: 'This goes 1'
170 | })
171 | const b = getBaseItemForSorting({
172 | metadataFieldValueSecondary: 'This goes 2'
173 | })
174 | const result = comparator(a, b)
175 | expect(result).toBe(A_GOES_FIRST)
176 | expect(sp).toBeCalledTimes(2)
177 | expect(sp).toHaveBeenNthCalledWith(1, CustomSortOrder.byMetadataFieldAlphabeticalReverse, OS_byModifiedTimeReverse, SortingLevelId.forPrimary)
178 | expect(sp).toHaveBeenNthCalledWith(2, CustomSortOrder.byMetadataFieldTrueAlphabetical, OS_byModifiedTimeReverse, SortingLevelId.forSecondary)
179 | })
180 | it( 'in complex case - secondary sort comparison fails, last resort default comes into play', () => {
181 | const a = getBaseItemForSorting({
182 | sortString: 'Second'
183 | })
184 | const b= getBaseItemForSorting({
185 | sortString: 'First'
186 | })
187 | const result = comparator(a,b)
188 | expect(result).toBe(B_GOES_FIRST)
189 | expect(sp).toBeCalledTimes(4)
190 | expect(sp).toHaveBeenNthCalledWith(1, CustomSortOrder.byMetadataFieldAlphabeticalReverse, OS_byModifiedTimeReverse, SortingLevelId.forPrimary)
191 | expect(sp).toHaveBeenNthCalledWith(2, CustomSortOrder.byMetadataFieldTrueAlphabetical, OS_byModifiedTimeReverse, SortingLevelId.forSecondary)
192 | expect(sp).toHaveBeenNthCalledWith(3, CustomSortOrder.byCreatedTime, OS_byModifiedTimeReverse, SortingLevelId.forDerivedPrimary )
193 | expect(sp).toHaveBeenNthCalledWith(4, CustomSortOrder.default, undefined, SortingLevelId.forDefaultWhenUnspecified)
194 | })
195 | })
196 | describe('at target folder level (aka derived)', () => {
197 | const comparator = getComparator(MultiLevelSortSpecTargetFolderLevel, OS_byModifiedTimeReverse)
198 | it('in simple case - derived secondary sort comparison succeeds', () => {
199 | const a = getBaseItemForSorting({
200 | metadataFieldValueForDerivedSecondary: 'This goes 2 first (reverse is in effect)'
201 | })
202 | const b = getBaseItemForSorting({
203 | metadataFieldValueForDerivedSecondary: 'This goes 1 second (reverse is in effect)'
204 | })
205 | const result = comparator(a, b)
206 | expect(result).toBe(A_GOES_FIRST)
207 | expect(sp).toBeCalledTimes(3)
208 | expect(sp).toHaveBeenNthCalledWith(1, CustomSortOrder.byMetadataFieldAlphabeticalReverse, OS_byModifiedTimeReverse, SortingLevelId.forPrimary)
209 | expect(sp).toHaveBeenNthCalledWith(2, CustomSortOrder.byCreatedTime, OS_byModifiedTimeReverse, SortingLevelId.forDerivedPrimary)
210 | expect(sp).toHaveBeenNthCalledWith(3, CustomSortOrder.byMetadataFieldTrueAlphabeticalReverse, OS_byModifiedTimeReverse, SortingLevelId.forDerivedSecondary)
211 | })
212 | it( 'in complex case - secondary sort comparison fails, last resort default comes into play', () => {
213 | const a = getBaseItemForSorting({
214 | sortString: 'Second'
215 | })
216 | const b= getBaseItemForSorting({
217 | sortString: 'First'
218 | })
219 | const result = comparator(a,b)
220 | expect(result).toBe(B_GOES_FIRST)
221 | expect(sp).toBeCalledTimes(4)
222 | expect(sp).toHaveBeenNthCalledWith(1, CustomSortOrder.byMetadataFieldAlphabeticalReverse, OS_byModifiedTimeReverse, SortingLevelId.forPrimary)
223 | expect(sp).toHaveBeenNthCalledWith(2, CustomSortOrder.byCreatedTime, OS_byModifiedTimeReverse, SortingLevelId.forDerivedPrimary)
224 | expect(sp).toHaveBeenNthCalledWith(3, CustomSortOrder.byMetadataFieldTrueAlphabeticalReverse, OS_byModifiedTimeReverse, SortingLevelId.forDerivedSecondary)
225 | expect(sp).toHaveBeenNthCalledWith(4, CustomSortOrder.default, undefined, SortingLevelId.forDefaultWhenUnspecified)
226 | })
227 | })
228 | describe('at group and at target folder level (aka derived)', () => {
229 | const comparator = getComparator(MultiLevelSortSpecAndTargetFolderLevel, OS_byCreatedTime)
230 | const mdataGetter = jest.spyOn(CustomSortModule, 'getMdata')
231 | beforeEach(() => {
232 | mdataGetter.mockClear()
233 | })
234 | it('most complex case - last resort default comes into play, all sort levels present, all involve metadata', () => {
235 | const a = getBaseItemForSorting({
236 | path: 'test 1', // Not used in comparisons, used only to identify source of compared metadata
237 | metadataFieldValue: 'm',
238 | metadataFieldValueSecondary: 'ms',
239 | metadataFieldValueForDerived: 'dm',
240 | metadataFieldValueForDerivedSecondary: 'dms'
241 | })
242 | const b= getBaseItemForSorting({
243 | path: 'test 2', // Not used in comparisons, used only to identify source of compared metadata
244 | metadataFieldValue: 'm',
245 | metadataFieldValueSecondary: 'ms',
246 | metadataFieldValueForDerived: 'dm',
247 | metadataFieldValueForDerivedSecondary: 'dms'
248 | })
249 | const result = Math.sign(comparator(a,b))
250 | expect(result).toBe(AB_EQUAL)
251 | expect(sp).toBeCalledTimes(5)
252 | expect(sp).toHaveBeenNthCalledWith(1, CustomSortOrder.byMetadataFieldAlphabetical, OS_byCreatedTime, SortingLevelId.forPrimary)
253 | expect(sp).toHaveBeenNthCalledWith(2, CustomSortOrder.byMetadataFieldAlphabeticalReverse, OS_byCreatedTime, SortingLevelId.forSecondary)
254 | expect(sp).toHaveBeenNthCalledWith(3, CustomSortOrder.byMetadataFieldTrueAlphabetical, OS_byCreatedTime, SortingLevelId.forDerivedPrimary)
255 | expect(sp).toHaveBeenNthCalledWith(4, CustomSortOrder.byMetadataFieldTrueAlphabeticalReverse, OS_byCreatedTime, SortingLevelId.forDerivedSecondary)
256 | expect(sp).toHaveBeenNthCalledWith(5, CustomSortOrder.default, undefined, SortingLevelId.forDefaultWhenUnspecified)
257 | expect(mdataGetter).toHaveBeenCalledTimes(8)
258 | expect(mdataGetter).toHaveBeenNthCalledWith(1, expect.objectContaining({path: 'test 1'}), SortingLevelId.forPrimary)
259 | expect(mdataGetter).toHaveNthReturnedWith(1, 'm')
260 | expect(mdataGetter).toHaveBeenNthCalledWith(2, expect.objectContaining({path: 'test 2'}), SortingLevelId.forPrimary)
261 | expect(mdataGetter).toHaveNthReturnedWith(2, 'm')
262 | expect(mdataGetter).toHaveBeenNthCalledWith(3, expect.objectContaining({path: 'test 1'}), SortingLevelId.forSecondary)
263 | expect(mdataGetter).toHaveNthReturnedWith(3, 'ms')
264 | expect(mdataGetter).toHaveBeenNthCalledWith(4, expect.objectContaining({path: 'test 2'}), SortingLevelId.forSecondary)
265 | expect(mdataGetter).toHaveNthReturnedWith(4, 'ms')
266 | expect(mdataGetter).toHaveBeenNthCalledWith(5, expect.objectContaining({path: 'test 1'}), SortingLevelId.forDerivedPrimary)
267 | expect(mdataGetter).toHaveNthReturnedWith(5, 'dm')
268 | expect(mdataGetter).toHaveBeenNthCalledWith(6, expect.objectContaining({path: 'test 2'}), SortingLevelId.forDerivedPrimary)
269 | expect(mdataGetter).toHaveNthReturnedWith(6, 'dm')
270 | expect(mdataGetter).toHaveBeenNthCalledWith(7, expect.objectContaining({path: 'test 1'}), SortingLevelId.forDerivedSecondary)
271 | expect(mdataGetter).toHaveNthReturnedWith(7, 'dms')
272 | expect(mdataGetter).toHaveBeenNthCalledWith(8, expect.objectContaining({path: 'test 2'}), SortingLevelId.forDerivedSecondary)
273 | expect(mdataGetter).toHaveNthReturnedWith(8, 'dms')
274 | })
275 | })
276 | })
277 | })
278 |
--------------------------------------------------------------------------------
/src/test/unit/custom-sort-utils.spec.ts:
--------------------------------------------------------------------------------
1 | import {
2 | CustomSortGroupType,
3 | CustomSortOrder,
4 | CustomSortSpec
5 | } from "../../custom-sort/custom-sort-types";
6 | import {
7 | collectSortingAndGroupingTypes,
8 | hasOnlyByBookmarkOrStandardObsidian,
9 | HasSortingOrGrouping,
10 | ImplicitSortspecForBookmarksIntegration
11 | } from "../../custom-sort/custom-sort-utils";
12 | import {SortingSpecProcessor, SortSpecsCollection} from "../../custom-sort/sorting-spec-processor";
13 |
14 | type NM = number
15 |
16 | const getHas = (gTotal?: NM, gBkmrk?: NM, gStar?: NM, gIcon?: NM, sTot?: NM, sBkmrk?: NM, sStd?: NM) => {
17 | const has: HasSortingOrGrouping = {
18 | grouping: {
19 | total: gTotal ||0,
20 | byBookmarks: gBkmrk ||0,
21 | byIcon: gIcon ||0
22 | },
23 | sorting: {
24 | total: sTot ||0,
25 | byBookmarks: sBkmrk ||0,
26 | standardObsidian: sStd ||0
27 | }
28 | }
29 | return has
30 | }
31 |
32 | describe('hasOnlyByBookmarkOrStandardObsidian and collectSortingAndGroupingTypes', () => {
33 | it('should handle empty spec correctly', () => {
34 | const spec: Partial|undefined|null = undefined
35 | const expectedHas: HasSortingOrGrouping = getHas()
36 | const has = collectSortingAndGroupingTypes(spec)
37 | const hasOnly = hasOnlyByBookmarkOrStandardObsidian(has)
38 | expect(has).toEqual(expectedHas)
39 | expect(hasOnly).toBeTruthy()
40 | })
41 | it('should handle empty spec correctly (null variant)', () => {
42 | const spec: Partial|undefined|null = null
43 | const expectedHas: HasSortingOrGrouping = getHas()
44 | const has = collectSortingAndGroupingTypes(spec)
45 | const hasOnly = hasOnlyByBookmarkOrStandardObsidian(has)
46 | expect(hasOnly).toBeTruthy()
47 | expect(has).toEqual(expectedHas)
48 | })
49 | it('should handle spec with empty orders correctly', () => {
50 | const spec: Partial|undefined = {
51 | groups: [
52 | {type: CustomSortGroupType.Outsiders, filesOnly: true},
53 | {type: CustomSortGroupType.Outsiders}
54 | ]
55 | }
56 | const expectedHas: HasSortingOrGrouping = getHas()
57 | const has = collectSortingAndGroupingTypes(spec as CustomSortSpec)
58 | const hasOnly = hasOnlyByBookmarkOrStandardObsidian(has)
59 | expect(hasOnly).toBeTruthy()
60 | expect(has).toEqual(expectedHas)
61 | })
62 | it('should detect not matching default order', () => {
63 | const spec: Partial|undefined = {
64 | defaultSorting: { order: CustomSortOrder.default },
65 | groups: [
66 | {
67 | type: CustomSortGroupType.ExactName,
68 | },
69 | {
70 | type: CustomSortGroupType.Outsiders,
71 | }
72 | ]
73 | }
74 | const expectedHas: HasSortingOrGrouping = getHas(1, 0, 0, 0, 1, 0, 0)
75 | const has = collectSortingAndGroupingTypes(spec as CustomSortSpec)
76 | const hasOnly = hasOnlyByBookmarkOrStandardObsidian(has)
77 | expect(hasOnly).toBeFalsy()
78 | expect(has).toEqual(expectedHas)
79 | })
80 | it('should detect not matching default secondary order', () => {
81 | const spec: Partial|undefined = {
82 | defaultSorting: { order: CustomSortOrder.byBookmarkOrder },
83 | defaultSecondarySorting: { order: CustomSortOrder.default },
84 | groups: [
85 | {
86 | type: CustomSortGroupType.BookmarkedOnly,
87 | },
88 | {
89 | type: CustomSortGroupType.Outsiders,
90 | }
91 | ]
92 | }
93 | const expectedHas: HasSortingOrGrouping = getHas(1, 1, 0, 0, 2, 1, 0)
94 | const has = collectSortingAndGroupingTypes(spec as CustomSortSpec)
95 | const hasOnly = hasOnlyByBookmarkOrStandardObsidian(has)
96 | expect(hasOnly).toBeFalsy()
97 | expect(has).toEqual(expectedHas)
98 | })
99 | it('should detect not matching order in group', () => {
100 | const spec: Partial|undefined = {
101 | defaultSorting: { order: CustomSortOrder.byBookmarkOrder },
102 | defaultSecondarySorting: { order: CustomSortOrder.standardObsidian },
103 | groups: [
104 | {
105 | type: CustomSortGroupType.ExactName,
106 | sorting: { order: CustomSortOrder.byCreatedTimeReverse }
107 | },
108 | {
109 | type: CustomSortGroupType.Outsiders,
110 | }
111 | ]
112 | }
113 | const expectedHas: HasSortingOrGrouping = getHas(1, 0, 0, 0, 3, 1, 1)
114 | const has = collectSortingAndGroupingTypes(spec as CustomSortSpec)
115 | const hasOnly = hasOnlyByBookmarkOrStandardObsidian(has)
116 | expect(hasOnly).toBeFalsy()
117 | expect(has).toEqual(expectedHas)
118 | })
119 | it('should detect not matching secondary order in group', () => {
120 | const spec: Partial|undefined = {
121 | defaultSorting: { order: CustomSortOrder.byBookmarkOrder },
122 | defaultSecondarySorting: { order: CustomSortOrder.standardObsidian },
123 | groups: [
124 | {
125 | type: CustomSortGroupType.ExactName,
126 | sorting: { order: CustomSortOrder.byBookmarkOrderReverse },
127 | secondarySorting: { order: CustomSortOrder.standardObsidian }
128 | },
129 | {
130 | type: CustomSortGroupType.Outsiders,
131 | sorting: { order: CustomSortOrder.byBookmarkOrder },
132 | secondarySorting: { order: CustomSortOrder.alphabetical }
133 | }
134 | ]
135 | }
136 | const expectedHas: HasSortingOrGrouping = getHas(1, 0, 0, 0, 6, 3, 2)
137 | const has = collectSortingAndGroupingTypes(spec as CustomSortSpec)
138 | const hasOnly = hasOnlyByBookmarkOrStandardObsidian(has)
139 | expect(hasOnly).toBeFalsy()
140 | expect(has).toEqual(expectedHas)
141 | })
142 | it('should detect matching orders at all levels', () => {
143 | const spec: Partial|undefined = {
144 | defaultSorting: { order: CustomSortOrder.byBookmarkOrder },
145 | defaultSecondarySorting: { order: CustomSortOrder.standardObsidian },
146 | groups: [
147 | {
148 | type: CustomSortGroupType.BookmarkedOnly,
149 | sorting: { order: CustomSortOrder.byBookmarkOrderReverse },
150 | secondarySorting: { order: CustomSortOrder.standardObsidian }
151 | },
152 | {
153 | type: CustomSortGroupType.Outsiders,
154 | sorting: { order: CustomSortOrder.byBookmarkOrder },
155 | secondarySorting: { order: CustomSortOrder.byBookmarkOrderReverse }
156 | }
157 | ]
158 | }
159 | const expectedHas: HasSortingOrGrouping = getHas(1, 1, 0, 0, 6, 4, 2)
160 | const has = collectSortingAndGroupingTypes(spec as CustomSortSpec)
161 | const hasOnly = hasOnlyByBookmarkOrStandardObsidian(has)
162 | expect(hasOnly).toBeTruthy()
163 | expect(has).toEqual(expectedHas)
164 | })
165 | })
166 |
167 | describe('ImplicitSortspecForBookmarksIntegration', () => {
168 | it('should correctly be recognized as only bookmark and obsidian standard', () => {
169 | const processor: SortingSpecProcessor = new SortingSpecProcessor();
170 | const inputTxtArr: Array = ImplicitSortspecForBookmarksIntegration.replace(/\t/gi, '').split('\n')
171 | const spec: SortSpecsCollection|null|undefined = processor.parseSortSpecFromText(
172 | inputTxtArr,
173 | 'mock-folder',
174 | 'custom-name-note.md',
175 | null,
176 | true
177 | )
178 | const expectedHas: HasSortingOrGrouping = getHas(1, 1, 0, 0, 2, 1, 1)
179 | const has = collectSortingAndGroupingTypes(spec?.sortSpecByPath!['/'])
180 | const hasOnly = hasOnlyByBookmarkOrStandardObsidian(has)
181 | expect(hasOnly).toBeTruthy()
182 | expect(has).toEqual(expectedHas)
183 | })
184 | })
185 |
186 | // TODO - czy tamto sprawdzanie dla itemów w rootowym filderze hasBookmarkInFolder dobrze zadziala
187 |
--------------------------------------------------------------------------------
/src/test/unit/macros.spec.ts:
--------------------------------------------------------------------------------
1 | import {
2 | expandMacros,
3 | expandMacrosInString
4 | } from "../../custom-sort/macros";
5 | import * as MacrosModule from '../../custom-sort/macros'
6 | import {
7 | CustomSortGroup,
8 | CustomSortSpec
9 | } from "../../custom-sort/custom-sort-types";
10 |
11 | describe('expandMacrosInString', () => {
12 | it.each([
13 | ['', ''],
14 | ['123', '123'],
15 | [' 123 ', ' 123 '],
16 | [' Abc{:%parent-folder-name%:}Def ', ' Abc{:%parent-folder-name%:}Def '],
17 | ['{:%parent-folder-name%:}Def ', '{:%parent-folder-name%:}Def '],
18 | [' Abc{:%parent-folder-name%:}', ' Abc{:%parent-folder-name%:}'],
19 | [' {:%parent-folder-name%:} xyz {:%parent-folder-name%:}', ' {:%parent-folder-name%:} xyz {:%parent-folder-name%:}'],
20 | [' {:%unknown%:} ',' {:%unknown%:} ']
21 | ])('%s should transform to %s when no parent folder', (source: string, expanded: string) => {
22 | const result1 = expandMacrosInString(source)
23 | const result2 = expandMacrosInString(source, '')
24 | expect(result1).toBe(expanded)
25 | expect(result2).toBe(expanded)
26 | })
27 | it.each([
28 | ['', ''],
29 | ['123', '123'],
30 | [' 123 ', ' 123 '],
31 | [' Abc{:%parent-folder-name%:}Def ', ' AbcSubFolder 5Def '],
32 | ['{:%parent-folder-name%:}Def ', 'SubFolder 5Def '],
33 | [' Abc{:%parent-folder-name%:}', ' AbcSubFolder 5'],
34 | [' {:%parent-folder-name%:} xyz {:%parent-folder-name%:}', ' SubFolder 5 xyz {:%parent-folder-name%:}'],
35 | [' {:%unknown%:} ',' {:%unknown%:} ']
36 | ])('%s should transform to %s when parent folder specified', (source: string, expanded: string) => {
37 | const PARENT = 'SubFolder 5'
38 | const result = expandMacrosInString(source, PARENT)
39 | expect(result).toBe(expanded)
40 | })
41 | })
42 |
43 | function mockGroup(gprefix: string, group: string, prefix: string, full: string, suffix: string): CustomSortGroup {
44 | const g: Partial = {
45 | exactText: gprefix + group + full,
46 | exactPrefix: gprefix + group + prefix,
47 | exactSuffix: gprefix + group + suffix
48 | }
49 | return g as CustomSortGroup
50 | }
51 |
52 | describe('expandMacros', () => {
53 | it('should invoke expand in all relevant text fields on all groups', () => {
54 | const sortSpec: Partial = {
55 | groups: [
56 | mockGroup('g-', '1-', 'abc', 'def', 'ghi'),
57 | mockGroup('g-', '2-', 'abc', 'def', 'ghi'),
58 | ],
59 | groupsShadow: [
60 | mockGroup('gs-', '1-', 'abc', 'def', 'ghi'),
61 | mockGroup('gs-', '2-', 'abc', 'def', 'ghi'),
62 | ]
63 | }
64 | const sp = jest.spyOn(MacrosModule, 'expandMacrosInString')
65 | const ParentFolder = 'Parent folder name'
66 | expandMacros(sortSpec as CustomSortSpec, ParentFolder)
67 | expect(sp).toBeCalledTimes(6)
68 | expect(sp).toHaveBeenNthCalledWith(1, 'gs-1-def', ParentFolder)
69 | expect(sp).toHaveBeenNthCalledWith(2, 'gs-1-abc', ParentFolder)
70 | expect(sp).toHaveBeenNthCalledWith(3, 'gs-1-ghi', ParentFolder)
71 | expect(sp).toHaveBeenNthCalledWith(4, 'gs-2-def', ParentFolder)
72 | expect(sp).toHaveBeenNthCalledWith(5, 'gs-2-abc', ParentFolder)
73 | expect(sp).toHaveBeenNthCalledWith(6, 'gs-2-ghi', ParentFolder)
74 | })
75 | it('should expand correctly in all relevant text fields on all groups, based on shadow groups', () => {
76 | const sortSpec: Partial = {
77 | groups: [
78 | mockGroup('g-', '1-', 'abc{:%parent-folder-name%:}', 'de{:%parent-folder-name%:}f', '{:%parent-folder-name%:}ghi'),
79 | mockGroup('g-', '2-', '{:%parent-folder-name%:}abc', 'd{:%parent-folder-name%:}ef', 'ghi{:%parent-folder-name%:}'),
80 | ],
81 | groupsShadow: [
82 | mockGroup('gs-', '1-', 'abc{:%parent-folder-name%:}', 'de{:%parent-folder-name%:}f', '{:%parent-folder-name%:}ghi'),
83 | mockGroup('gs-', '2-', '{:%parent-folder-name%:}abc', 'd{:%parent-folder-name%:}ef', 'ghi{:%parent-folder-name%:}'),
84 | ]
85 | }
86 | const originalSortSpec: Partial = {
87 | groups: [...sortSpec.groups!],
88 | groupsShadow: [...sortSpec.groupsShadow!]
89 | }
90 | const ParentFolder = 'Parent folder name'
91 | expandMacros(sortSpec as CustomSortSpec, ParentFolder)
92 | expect(sortSpec.groups![0].exactText).toBe(originalSortSpec.groups![0].exactText)
93 | expect(sortSpec.groups![0].exactPrefix).toBe(originalSortSpec.groups![0].exactPrefix)
94 | expect(sortSpec.groups![0].exactSuffix).toBe(originalSortSpec.groups![0].exactSuffix)
95 | expect(sortSpec.groups![1].exactText).toBe(originalSortSpec.groups![1].exactText)
96 | expect(sortSpec.groups![1].exactPrefix).toBe(originalSortSpec.groups![1].exactPrefix)
97 | expect(sortSpec.groups![1].exactSuffix).toBe(originalSortSpec.groups![1].exactSuffix)
98 | expect(sortSpec.groupsShadow![0].exactText).toBe('gs-1-deParent folder namef')
99 | expect(sortSpec.groupsShadow![0].exactPrefix).toBe('gs-1-abcParent folder name')
100 | expect(sortSpec.groupsShadow![0].exactSuffix).toBe('gs-1-Parent folder nameghi')
101 | expect(sortSpec.groupsShadow![1].exactText).toBe('gs-2-dParent folder nameef')
102 | expect(sortSpec.groupsShadow![1].exactPrefix).toBe('gs-2-Parent folder nameabc')
103 | expect(sortSpec.groupsShadow![1].exactSuffix).toBe('gs-2-ghiParent folder name')
104 | })
105 | })
106 |
--------------------------------------------------------------------------------
/src/test/unit/mdata-extractors.spec.ts:
--------------------------------------------------------------------------------
1 | import {
2 | _unitTests
3 | } from '../../custom-sort/mdata-extractors'
4 |
5 | describe('extractor for date(dd/mm/yyyy)', () => {
6 | const params = [
7 | // Positive
8 | ['03/05/2019', '2019-05-03//'],
9 | ['103/05/2019', '2019-05-03//'],
10 | ['103/05/20193232', '2019-05-03//'],
11 | ['99/99/9999', '9999-99-99//'],
12 | ['00/00/0000', '0000-00-00//'],
13 | ['Created at: 03/05/2019', '2019-05-03//'],
14 | ['03/05/2019 | 22:00', '2019-05-03//'],
15 | ['Created at: 03/05/2019 | 22:00', '2019-05-03//'],
16 |
17 | // Negative
18 | ['88-Dec-2012', undefined],
19 | ['13-JANUARY-2012', undefined],
20 | ['1 .1', undefined],
21 | ['', undefined],
22 | ['abc', undefined],
23 | ['def-abc', undefined],
24 | ['3/5/2019', undefined],
25 | ];
26 | it.each(params)('>%s< should become %s', (s: string, out: string) => {
27 | expect(_unitTests.extractorFnForDate_ddmmyyyy(s)).toBe(out)
28 | })
29 | })
30 |
31 | describe('extractor for date(mm/dd/yyyy)', () => {
32 | const params = [
33 | // Positive
34 | ['03/05/2019', '2019-03-05//'],
35 | ['103/05/2019', '2019-03-05//'],
36 | ['103/05/20193232', '2019-03-05//'],
37 | ['99/99/9999', '9999-99-99//'],
38 | ['00/00/0000', '0000-00-00//'],
39 | ['Created at: 03/05/2019', '2019-03-05//'],
40 | ['03/05/2019 | 22:00', '2019-03-05//'],
41 | ['Created at: 03/05/2019 | 22:00', '2019-03-05//'],
42 |
43 | // Negative
44 | ['88-Dec-2012', undefined],
45 | ['13-JANUARY-2012', undefined],
46 | ['1 .1', undefined],
47 | ['', undefined],
48 | ['abc', undefined],
49 | ['def-abc', undefined],
50 | ['3/5/2019', undefined],
51 | ];
52 | it.each(params)('>%s< should become %s', (s: string, out: string) => {
53 | expect(_unitTests.extractorFnForDate_mmddyyyy(s)).toBe(out)
54 | })
55 | })
56 |
--------------------------------------------------------------------------------
/src/test/unit/utils.spec.ts:
--------------------------------------------------------------------------------
1 | import {
2 | lastPathComponent,
3 | extractParentFolderPath,
4 | extractBasename
5 | } from "../../utils/utils";
6 |
7 | describe('lastPathComponent and extractParentFolderPath', () => {
8 | it.each([
9 | ['a folder', '', 'a folder'],
10 | ['a/subfolder', 'a', 'subfolder'],
11 | ['parent/child', 'parent', 'child'],
12 | ['','',''],
13 | [' ','',' '],
14 | ['/strange', '', 'strange'],
15 | ['a/b/c/', 'a/b/c', ''],
16 | ['d d d/e e e/f f f/ggg ggg', 'd d d/e e e/f f f', 'ggg ggg'],
17 | ['/','',''],
18 | [' / ',' ',' '],
19 | [' /',' ',''],
20 | ['/ ','',' ']
21 | ])('should from %s extract %s and %s', (path: string, parentPath: string, lastComponent: string) => {
22 | const extractedParentPath: string = extractParentFolderPath(path)
23 | const extractedLastComponent: string = lastPathComponent(path)
24 | expect(extractedParentPath).toBe(parentPath)
25 | expect(extractedLastComponent).toBe(lastComponent)
26 | }
27 | )
28 | })
29 |
30 | describe('extractBasename', () => {
31 | const params: Array<(string|undefined)[]> = [
32 | // Obvious
33 | ['index', 'index'],
34 | ['index.md', 'index'],
35 | // Edge cases
36 | ['',''],
37 | [undefined,undefined],
38 | ['.','.'],
39 | ['.md',''],
40 | ['.md.md','.md']
41 | ];
42 | it.each(params)('>%s< should result in %s', (s: string|undefined, out: string|undefined) => {
43 | expect(extractBasename(s)).toBe(out)
44 | })
45 | })
46 |
--------------------------------------------------------------------------------
/src/test/unit/week-of-year.spec.ts:
--------------------------------------------------------------------------------
1 | import {_unitTests, getDateForWeekOfYear} from "../../utils/week-of-year"
2 |
3 | const paramsForWeekOf1stOfJan = [
4 | [2015,'2014-12-29T00:00:00.000Z','same as U.S.'], // 1st Jan on Thu, ISO = U.S.
5 | [2020,'2019-12-30T00:00:00.000Z','same as U.S.'], // 1st Jan on Wed, ISO = U.S.
6 | [2021,'2020-12-28T00:00:00.000Z','2021-01-04T00:00:00.000Z'], // 1st Jan on Fri, ISO != U.S.
7 | [2022,'2021-12-27T00:00:00.000Z','2022-01-03T00:00:00.000Z'], // 1st Jan on Sat, ISO != U.S.
8 | [2023,'2022-12-26T00:00:00.000Z','2023-01-02T00:00:00.000Z'], // 1st Jan on Sun, ISO != U.S.
9 | [2024,'2024-01-01T00:00:00.000Z','same as U.S.'], // 1st Jan on Mon, ISO = U.S.
10 | [2025,'2024-12-30T00:00:00.000Z','same as U.S.'] // 1st Jan on Wed, ISO = U.S.
11 | ]
12 |
13 | const paramsFor10thWeek = [
14 | [2019,'2019-03-04T00:00:00.000Z','same as U.S.'],
15 | [1999,'1999-03-01T00:00:00.000Z','1999-03-08T00:00:00.000Z'],
16 | [1683,'1683-03-01T00:00:00.000Z','1683-03-08T00:00:00.000Z'],
17 | [1410,'1410-03-05T00:00:00.000Z','same as U.S.'],
18 | [1996,'1996-03-04T00:00:00.000Z','same as U.S.'],
19 | [2023,'2023-02-27T00:00:00.000Z','2023-03-06T00:00:00.000Z'],
20 | [2025,'2025-03-03T00:00:00.000Z','same as U.S.']
21 | ]
22 |
23 | describe('calculateMondayDateIn2stWeekOfYear', () => {
24 | it.each(paramsForWeekOf1stOfJan)('year >%s< should result in %s (U.S.) and %s (ISO)', (year: number, dateOfMondayUS: string, dateOfMondayISO: string) => {
25 | const dateUS = new Date(dateOfMondayUS).getTime()
26 | const dateISO = 'same as U.S.' === dateOfMondayISO ? dateUS : new Date(dateOfMondayISO).getTime()
27 | const mondayData = _unitTests.calculateMondayDateIn2stWeekOfYear(year)
28 | expect(mondayData.mondayDateOf1stWeekUS).toBe(dateUS)
29 | expect(mondayData.mondayDateOf1stWeekISO).toBe(dateISO)
30 | })
31 | })
32 |
33 | describe('getDateForWeekOfYear', () => {
34 | it.each(paramsForWeekOf1stOfJan)('For year >%s< 1st week should start on %s (U.S.) and %s (ISO)', (year: number, dateOfMondayUS: string, dateOfMondayISO: string) => {
35 | const dateUS = new Date(dateOfMondayUS)
36 | const dateISO = 'same as U.S.' === dateOfMondayISO ? dateUS : new Date(dateOfMondayISO)
37 | expect(getDateForWeekOfYear(year, 1)).toStrictEqual(dateUS)
38 | expect(getDateForWeekOfYear(year, 1, true)).toStrictEqual(dateISO)
39 | })
40 | it.each(paramsFor10thWeek)('For year >%s< 10th week should start on %s (U.S.) and %s (ISO)', (year: number, dateOfMondayUS: string, dateOfMondayISO: string) => {
41 | const dateUS = new Date(dateOfMondayUS)
42 | const dateISO = 'same as U.S.' === dateOfMondayISO ? dateUS : new Date(dateOfMondayISO)
43 | expect(getDateForWeekOfYear(year, 10)).toStrictEqual(dateUS)
44 | expect(getDateForWeekOfYear(year, 10, true)).toStrictEqual(dateISO)
45 | })
46 | it('should correctly handle edge case - a year spanning 54 weeks (leap year starting on Sun)', () => {
47 | const USstandard = false
48 | const SUNDAY = true
49 | // This works in U.S. standard only, where 1st week can start on Sunday
50 | expect(getDateForWeekOfYear(2012,1)).toStrictEqual(new Date('2011-12-26T00:00:00.000Z'))
51 | expect(getDateForWeekOfYear(2012,1, USstandard, SUNDAY)).toStrictEqual(new Date('2012-01-01T00:00:00.000Z'))
52 | expect(getDateForWeekOfYear(2012,54)).toStrictEqual(new Date('2012-12-31T00:00:00.000Z'))
53 | expect(getDateForWeekOfYear(2012,54, USstandard, SUNDAY)).toStrictEqual(new Date('2013-01-06T00:00:00.000Z'))
54 | })
55 | })
56 |
--------------------------------------------------------------------------------
/src/types/types.d.ts:
--------------------------------------------------------------------------------
1 | import {PluginInstance, TFolder, WorkspaceLeaf} from "obsidian";
2 |
3 | // Needed to support monkey-patching functions of FileExplorerLeaf or FileExplorerView
4 |
5 | declare module 'obsidian' {
6 | export interface ViewRegistry {
7 | viewByType: Record unknown>;
8 | }
9 |
10 | // undocumented internal interface - for experimental features
11 | export interface PluginInstance {
12 | id: string;
13 | }
14 |
15 | export type CommunityPluginId = string
16 |
17 | // undocumented internal interface - for experimental features
18 | export interface CommunityPlugin {
19 | manifest: {
20 | id: CommunityPluginId
21 | }
22 | _loaded: boolean
23 | }
24 |
25 | // undocumented internal interface - for experimental features
26 | export interface CommunityPlugins {
27 | enabledPlugins: Set
28 | plugins: {[key: CommunityPluginId]: CommunityPlugin}
29 | }
30 |
31 | export interface App {
32 | plugins: CommunityPlugins;
33 | internalPlugins: InternalPlugins; // undocumented internal API - for experimental features
34 | viewRegistry: ViewRegistry;
35 | }
36 |
37 | // undocumented internal interface - for experimental features
38 | export interface InstalledPlugin {
39 | enabled: boolean;
40 | instance: PluginInstance;
41 | }
42 |
43 | // undocumented internal interface - for experimental features
44 | export interface InternalPlugins {
45 | plugins: Record;
46 | getPluginById(id: string): InstalledPlugin;
47 | }
48 |
49 | export interface FileExplorerView extends View {
50 | getSortedFolderItems(sortedFolder: TFolder): any[];
51 |
52 | requestSort(): void;
53 |
54 | sortOrder: string
55 | }
56 |
57 | export interface FileExplorerLeaf extends WorkspaceLeaf {
58 | view: FileExplorerView
59 | get isDeferred(): boolean // since Obsidian 1.7.2
60 | }
61 |
62 | interface MenuItem {
63 | setSubmenu: () => Menu;
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/src/utils/Bookmarks Core Plugin integration design.md:
--------------------------------------------------------------------------------
1 | Integration with Bookmarks core plugin:
2 | - support two approaches _at the same time_:
3 | - (A) structured bookmarks inside a dedicated bookmarks group, and
4 | - (B) a flat list of bookmarks inside the dedicated bookmarks group
5 |
6 | For (A):
7 | - preferred
8 | - a folder is represented by a group in bookmarks
9 | - a file is represented by a file-with-block
10 | - this also applied to non-md files, like jpg and others
11 | - guarantees _'hiding'_ the bookmarks-for-sorting from regular bookmarks usage scenarios
12 | - bookmark entries for sorting are encapsulated in the dedicated group
13 | - they don't interfere with bookmarking of files and folders via standard bookmarking
14 | - only exact location of file bookmark / group matches for sorting order in file explorer
15 | - the contextual bookmark menus always work in (A) mode
16 | - the contextual menus create / modify the bookmarks structure on-the-fly
17 |
18 | For (B):
19 | - discouraged, yet supported (exception for some edge cases)
20 | - typically a result of manual bookmarks management
21 | - for small number of items seems reasonable
22 | - for flat vaults it could look same as for (A)
23 | - groups don't have a 'path' attribute, their path is determined by their location
24 | - bookmarked folders represent folders if inside the bookmarks group for sorting
25 | - yet in this way they interfere with regular bookmarks scenario
26 | - file bookmarks work correctly in non-interfering way thanks to the _'artificial block reference'_
27 | - file bookmarks not having the _'artificial block ref'_ work as well
28 | - if they are in the designated bookmarks group
29 | - if there isn't a duplicate, which has the _'artificial block ref'_
30 | - yet in this way they interfere with regular bookmarks scenario
31 |
32 | -[ ] TODO: review again the 'item moved' and 'item deleted' scenarios (they look ok, check if they don't delete/move too much)
33 | - [x] fundamental question 1: should 'move' create a bookmark entry/structure if it is not covered by bookmarks?
34 | - Answer: the moved item is removed from bookmarks. If it is a group with descendants not transparent for sorting,
35 | it is renamed to become transparent for sorting.
36 | By design, the order of items is property of the parent folder (the container) and not the items
37 | - [x] fundamental question 2: should 'move' create a bookmark entry if moved item was not bookmarked, yet is moved to a folder covered by bookmarks?
38 | - Answer: same as for previous point.
39 | - [x] review from (A) and (B) perspective
40 | - Answer: scenario (A) is fully handled by 'item moved' and 'item deleted'.
41 | scenario (B) is partially handled for 'item moved'. Details to be read from code (too complex to cover here)
42 | - [x] consider deletion of item outside of bookmarks sorting container group
43 | Answer: bookmark items outside of bookmarks sorting container are not manipulated by custom-sort plugin
44 | to not interfere with standard Bookmarks scenarios
45 | - [x] consider moving an item outside of bookmarks group
46 | - Answer: question not relevant. Items are moved in file explorer and bookmarks only reflect that, if needed.
47 | Hence there is no concept of 'moving an item outside of bookmarks group' - bookmarks group only exists in bookmarks
48 | - [x] edge case: bookmarked item is a group, the deleted/moved is a file, not a folder --> what to do?
49 | - Answer: for moved files, only file bookmarks are scanned (and handles), for moved folders, only groups are scanned (and handled).
50 | - [x] delete all instances at any level of bookmarks structure in 'delete' handler
51 | - Answer: only instances of (A) or (B) are deleted. Items outside of bookmarks container for sorting or
52 | in invalid locations in bookmarks hierarchy are ignored
53 |
54 |
55 |
56 |
--------------------------------------------------------------------------------
/src/utils/ObsidianIconFolderPluginSignature.ts:
--------------------------------------------------------------------------------
1 | import {App, CommunityPlugin, TAbstractFile} from "obsidian";
2 |
3 | // For https://github.com/FlorianWoelki/obsidian-icon-folder
4 |
5 | export const ObsidianIconFolderPlugin_getData_methodName = 'getData'
6 |
7 | export interface FolderIconObject {
8 | iconName: string | null;
9 | inheritanceIcon: string;
10 | }
11 |
12 | export type ObsidianIconFolderPlugin_Data = Record
13 |
14 | export interface ObsidianIconFolder_PluginInstance extends CommunityPlugin {
15 | [ObsidianIconFolderPlugin_getData_methodName]: () => ObsidianIconFolderPlugin_Data
16 | }
17 |
18 | // https://github.com/FlorianWoelki/obsidian-icon-folder/blob/fd9c7df1486744450cec3d7ee9cee2b34d008e56/manifest.json#L2
19 | export const ObsidianIconFolderPluginId: string = 'obsidian-icon-folder'
20 |
21 | export const getIconFolderPlugin = (app: App): ObsidianIconFolder_PluginInstance | undefined => {
22 | const iconFolderPlugin: CommunityPlugin | undefined = app?.plugins?.plugins?.[ObsidianIconFolderPluginId]
23 | if (iconFolderPlugin && iconFolderPlugin._loaded && app?.plugins?.enabledPlugins?.has(ObsidianIconFolderPluginId)) {
24 | const iconFolderPluginInstance: ObsidianIconFolder_PluginInstance = iconFolderPlugin as ObsidianIconFolder_PluginInstance
25 | // defensive programming, in case the community plugin changes its internal APIs
26 | if (typeof iconFolderPluginInstance?.[ObsidianIconFolderPlugin_getData_methodName] === 'function') {
27 | return iconFolderPluginInstance
28 | }
29 | }
30 | }
31 |
32 | // Intentionally partial and simplified, only detect icons configured directly,
33 | // ignoring any icon inheritance or regexp-based applied icons
34 | export const determineIconOf = (entry: TAbstractFile, iconFolderPluginInstance: ObsidianIconFolder_PluginInstance): string | undefined => {
35 | const iconsData: ObsidianIconFolderPlugin_Data | undefined = iconFolderPluginInstance[ObsidianIconFolderPlugin_getData_methodName]()
36 | const entryForPath: any = iconsData?.[entry.path]
37 | // Icons configured directly
38 | if (typeof entryForPath === 'string') {
39 | return entryForPath
40 | } else if (typeof (entryForPath as FolderIconObject)?.iconName === 'string') {
41 | return (entryForPath as FolderIconObject)?.iconName ?? undefined
42 | } else {
43 | return undefined
44 | }
45 | }
46 |
47 |
48 |
--------------------------------------------------------------------------------
/src/utils/utils.ts:
--------------------------------------------------------------------------------
1 | // syntax sugar for checking for optional numbers equal to zero (and other similar cases)
2 | export function isDefined(o: any): boolean {
3 | return o !== undefined && o !== null;
4 | }
5 |
6 | export function last(o: Array): T | undefined {
7 | return o?.length > 0 ? o[o.length - 1] : undefined
8 | }
9 |
10 | export function lastPathComponent(path: string): string {
11 | const lastPathSeparatorIdx = (path ?? '').lastIndexOf('/')
12 | return lastPathSeparatorIdx >= 0 ? path.substring(lastPathSeparatorIdx + 1) : path
13 | }
14 |
15 | export function extractParentFolderPath(path: string): string {
16 | const lastPathSeparatorIdx = (path ?? '').lastIndexOf('/')
17 | return lastPathSeparatorIdx > 0 ? path.substring(0, lastPathSeparatorIdx) : ''
18 | }
19 |
20 | export function extractBasename (configEntry: string | undefined): string | undefined {
21 | if (typeof configEntry === 'string' && configEntry.endsWith('.md')) {
22 | return configEntry.slice(0, -'.md'.length)
23 | } else {
24 | return configEntry
25 | }
26 | }
27 |
28 | export class ValueOrError {
29 | constructor(private value?: V, private error?: E) {
30 | if (value) this.error = undefined
31 | }
32 | public setValue(value: V): ValueOrError {
33 | this.value = value
34 | this.error = undefined
35 | return this
36 | }
37 | public setError(error: E): ValueOrError {
38 | this.value = undefined
39 | this.error = error
40 | return this
41 | }
42 | public get v() {
43 | return this.value
44 | }
45 | public get e() {
46 | return this.error
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/src/utils/week-of-year.ts:
--------------------------------------------------------------------------------
1 |
2 | // Cache of start of years and number of days in the 1st week
3 | interface MondayCache {
4 | year: number // full year, e.g. 2015
5 | mondayDateOf1stWeekUS: number // U.S. standard, the 1st of Jan determines the first week, monday can be in Dec of previous year
6 | sundayDateOf1stWeekUS: number
7 | mondayDateOf1stWeekISO: number // ISO standard, when the first Thursday of the year determines week numbering
8 | sundayDateOf1stWeekISO: number
9 | }
10 |
11 | type YEAR = number
12 | const DAY_OF_MILIS = 60*60*24*1000
13 | const DAYS_IN_WEEK = 7
14 |
15 | const MondaysCache: { [key: YEAR]: MondayCache } = {}
16 |
17 | const calculateMondayDateIn1stWeekOfYear = (year: number): MondayCache => {
18 | const firstSecondOfYear = new Date(`${year}-01-01T00:00:00.000Z`)
19 | const SUNDAY = 0
20 | const MONDAY = 1
21 | const THURSDAY = 4
22 | const FRIDAY = 5
23 | const SATURDAY = 6
24 |
25 | const dayOfWeek = firstSecondOfYear.getDay()
26 | let daysToPrevMonday: number = 0 // For the Monday itself
27 | if (dayOfWeek === SUNDAY) { // Sunday
28 | daysToPrevMonday = DAYS_IN_WEEK - 1
29 | } else if (dayOfWeek > MONDAY) { // Tue - Sat
30 | daysToPrevMonday = dayOfWeek - MONDAY
31 | }
32 |
33 | // for U.S. the first week is the one with Jan 1st,
34 | // for ISO standard, the first week is the one which contains the 1st Thursday of the year
35 | const useISOoffset = [FRIDAY, SATURDAY, SUNDAY].includes(dayOfWeek) ? DAYS_IN_WEEK : 0
36 |
37 | return {
38 | year: year,
39 | mondayDateOf1stWeekUS: new Date(firstSecondOfYear).setDate(firstSecondOfYear.getDate() - daysToPrevMonday),
40 | sundayDateOf1stWeekUS: new Date(firstSecondOfYear).setDate(firstSecondOfYear.getDate() - daysToPrevMonday + DAYS_IN_WEEK - 1),
41 | mondayDateOf1stWeekISO: new Date(firstSecondOfYear).setDate(firstSecondOfYear.getDate() - daysToPrevMonday + useISOoffset),
42 | sundayDateOf1stWeekISO: new Date(firstSecondOfYear).setDate(firstSecondOfYear.getDate() - daysToPrevMonday + useISOoffset + DAYS_IN_WEEK - 1),
43 | }
44 | }
45 |
46 | // Week number = 1 to 54, U.S. standard by default, can also work in ISO (parameter driven)
47 | export const getDateForWeekOfYear = (year: number, weekNumber: number, useISO?: boolean, sunday?: boolean): Date => {
48 | const WEEK_OF_MILIS = DAYS_IN_WEEK * DAY_OF_MILIS
49 | const dataOfMondayIn1stWeekOfYear = (MondaysCache[year] ??= calculateMondayDateIn1stWeekOfYear(year))
50 | const mondayOfTheRequestedWeek =
51 | (useISO ? dataOfMondayIn1stWeekOfYear.mondayDateOf1stWeekISO : dataOfMondayIn1stWeekOfYear.mondayDateOf1stWeekUS)
52 | + (weekNumber-1)*WEEK_OF_MILIS
53 |
54 | const sundayOfTheRequestedWeek =
55 | (useISO ? dataOfMondayIn1stWeekOfYear.sundayDateOf1stWeekISO : dataOfMondayIn1stWeekOfYear.sundayDateOf1stWeekUS)
56 | + (weekNumber-1)*WEEK_OF_MILIS
57 |
58 | return new Date(sunday ? sundayOfTheRequestedWeek : mondayOfTheRequestedWeek)
59 | }
60 |
61 | export const _unitTests = {
62 | calculateMondayDateIn2stWeekOfYear: calculateMondayDateIn1stWeekOfYear
63 | }
64 |
--------------------------------------------------------------------------------
/styles.css:
--------------------------------------------------------------------------------
1 | /* Unsure if this file of plugin is required (even empty) or not */
2 |
3 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "baseUrl": ".",
4 | "inlineSourceMap": true,
5 | "inlineSources": true,
6 | "allowSyntheticDefaultImports": true,
7 | "module": "ESNext",
8 | "target": "ES6",
9 | "allowJs": false,
10 | "noImplicitAny": true,
11 | "moduleResolution": "node",
12 | "importHelpers": true,
13 | "isolatedModules": true,
14 | "strictNullChecks": true,
15 | "lib": [
16 | "DOM",
17 | "ES5",
18 | "ES6",
19 | "ES7"
20 | ]
21 | },
22 | "include": [
23 | "**/*.ts"
24 | ]
25 | }
26 |
--------------------------------------------------------------------------------
/version-bump.mjs:
--------------------------------------------------------------------------------
1 | import { readFileSync, writeFileSync } from "fs";
2 |
3 | const targetVersion = process.env.npm_package_version;
4 |
5 | // read minAppVersion from manifest.json and bump version to target version
6 | let manifest = JSON.parse(readFileSync("manifest.json", "utf8"));
7 | const { minAppVersion } = manifest;
8 | manifest.version = targetVersion;
9 | writeFileSync("manifest.json", JSON.stringify(manifest, null, "\t"));
10 |
11 | // update versions.json with target version and minAppVersion from manifest.json
12 | let versions = JSON.parse(readFileSync("versions.json", "utf8"));
13 | versions[targetVersion] = minAppVersion;
14 | writeFileSync("versions.json", JSON.stringify(versions, null, "\t"));
15 |
--------------------------------------------------------------------------------
/versions.json:
--------------------------------------------------------------------------------
1 | {
2 | "0.5.188": "0.12.0",
3 | "0.5.189": "0.12.0",
4 | "0.6.0": "0.12.0",
5 | "0.6.1": "0.12.0",
6 | "0.6.2": "0.12.0",
7 | "0.7.0": "0.15.0",
8 | "0.7.1": "0.15.0",
9 | "0.7.2": "0.15.0",
10 | "0.8.0": "0.15.0",
11 | "0.8.1": "0.15.0",
12 | "0.8.2": "0.15.0",
13 | "0.8.3": "0.15.0",
14 | "0.8.4": "0.15.0",
15 | "1.0.0": "0.15.0",
16 | "1.0.1": "0.15.0",
17 | "1.0.2": "0.15.0",
18 | "1.0.3": "0.15.0",
19 | "1.1.0": "0.15.0",
20 | "1.2.0": "0.15.0",
21 | "1.3.0": "0.15.0",
22 | "1.4.0": "0.15.0",
23 | "1.5.0": "0.15.0",
24 | "1.6.0": "0.15.0",
25 | "1.6.1": "0.15.0",
26 | "1.6.2": "0.15.0",
27 | "1.6.3": "0.15.0",
28 | "1.7.0": "0.15.0",
29 | "1.7.1": "0.15.0",
30 | "1.7.2": "0.15.0",
31 | "1.8.2": "0.15.0",
32 | "1.9.0": "0.15.0",
33 | "1.9.1": "0.15.0",
34 | "1.9.2": "0.15.0",
35 | "2.0.1": "0.16.2",
36 | "2.0.2": "0.16.2",
37 | "2.1.0": "0.16.2",
38 | "2.1.1": "0.16.2",
39 | "2.1.2": "0.16.2",
40 | "2.1.3": "0.16.2",
41 | "2.1.4": "0.16.2",
42 | "2.1.5": "0.16.2",
43 | "2.1.7": "0.16.2",
44 | "2.1.8": "0.16.2",
45 | "2.1.9": "0.16.2",
46 | "2.1.10": "0.16.2",
47 | "2.1.11": "0.16.2",
48 | "2.1.12": "0.16.2",
49 | "2.1.13": "0.16.2",
50 | "2.1.14": "0.16.2",
51 | "2.1.15": "0.16.2",
52 | "3.0.0": "1.7.2",
53 | "3.0.1": "1.7.2",
54 | "3.1.0": "1.7.2",
55 | "3.1.1": "1.7.2",
56 | "3.1.2": "1.7.2",
57 | "3.1.3": "1.7.2",
58 | "3.1.4": "1.7.2",
59 | "3.1.5": "1.7.2"
60 | }
61 |
--------------------------------------------------------------------------------