Merge pull request #9 from SebastianMC/merge-upstream-1

Merge upstream obsidianmd/obsidian-sample-plugin + bugfix

Author: SebastianMC

esbuild.config.mjs

@@ -21,30 +21,20 @@ esbuild.build({
 		'obsidian',
 		'electron',
 		'@codemirror/autocomplete',
-		'@codemirror/closebrackets',
 		'@codemirror/collab',
 		'@codemirror/commands',
-		'@codemirror/comment',
-		'@codemirror/fold',
-		'@codemirror/gutter',
-		'@codemirror/highlight',
-		'@codemirror/history',
 		'@codemirror/language',
 		'@codemirror/lint',
-		'@codemirror/matchbrackets',
-		'@codemirror/panel',
-		'@codemirror/rangeset',
-		'@codemirror/rectangular-selection',
 		'@codemirror/search',
 		'@codemirror/state',
-		'@codemirror/stream-parser',
-		'@codemirror/text',
-		'@codemirror/tooltip',
 		'@codemirror/view',
+		'@lezer/common',
+		'@lezer/highlight',
+		'@lezer/lr',
 		...builtins],
 	format: 'cjs',
 	watch: !prod,
-	target: 'es2016',
+	target: 'es2018',
 	logLevel: "info",
 	sourcemap: prod ? false : 'inline',
 	minify: prod,

package.json

@@ -18,15 +18,15 @@
 	"devDependencies": {
 		"@types/jest": "^28.1.2",
 		"@types/node": "^16.11.6",
-		"@typescript-eslint/eslint-plugin": "^5.2.0",
-		"@typescript-eslint/parser": "^5.2.0",
-		"builtin-modules": "^3.2.0",
-		"esbuild": "0.13.12",
+		"@typescript-eslint/eslint-plugin": "5.29.0",
+		"@typescript-eslint/parser": "5.29.0",
+		"builtin-modules": "3.3.0",
+		"esbuild": "0.14.47",
 		"jest": "^28.1.1",
 		"monkey-around": "^2.3.0",
 		"obsidian": "^0.15.4",
 		"ts-jest": "^28.0.5",
-		"tslib": "2.3.1",
-		"typescript": "4.4.4"
+		"tslib": "2.4.0",
+		"typescript": "4.7.4"
 	}
 }

src/custom-sort/custom-sort-types.ts

@@ -14,15 +14,16 @@ export enum CustomSortOrder {
 	byModifiedTimeReverse,
 	byCreatedTime,
 	byCreatedTimeReverse,
-	standardObsidian// Let the folder sorting be in hands of Obsidian, whatever user selected in the UI
+	standardObsidian,  // Let the folder sorting be in hands of Obsidian, whatever user selected in the UI
+	default = alphabetical
 }
 
 export interface RecognizedOrderValue {
 	order: CustomSortOrder
 	secondaryOrder?: CustomSortOrder
 }
 
-export type NormalizerFn = (s: string) => string
+export type NormalizerFn = (s: string) => string | null
 
 export interface RegExpSpec {
 	regex: RegExp

src/custom-sort/custom-sort.spec.ts

@@ -1,4 +1,4 @@
-import {TFile} from 'obsidian';
+import {TFile, TFolder, Vault} from 'obsidian';
 import {determineSortingGroup} from './custom-sort';
 import {CustomSortGroupType, CustomSortSpec} from './custom-sort-types';
 import {CompoundDashNumberNormalizerFn, CompoundDotRomanNumberNormalizerFn} from "./sorting-spec-processor";
@@ -12,10 +12,10 @@ const mockTFile = (basename: string, ext: string, size?: number, ctime?: number,
 		},
 		basename: basename,
 		extension: ext,
-		vault: null,
+		vault: {} as Vault, // To satisfy TS typechecking
 		path: `Some parent folder/${basename}.${ext}`,
 		name: `${basename}.${ext}`,
-		parent: null
+		parent: {} as TFolder // To satisfy TS typechecking
 	}
 }
 

src/custom-sort/custom-sort.ts

@@ -1,10 +1,5 @@
-import {TFile, TFolder, requireApiVersion} from 'obsidian';
-import {
-	CustomSortGroup,
-	CustomSortGroupType,
-	CustomSortOrder,
-	CustomSortSpec
-} from "./custom-sort-types";
+import {requireApiVersion, TFile, TFolder} from 'obsidian';
+import {CustomSortGroup, CustomSortGroupType, CustomSortOrder, CustomSortSpec} from "./custom-sort-types";
 import {isDefined} from "../utils/utils";
 
 let Collator = new Intl.Collator(undefined, {
@@ -15,7 +10,7 @@ let Collator = new Intl.Collator(undefined, {
 
 interface FolderItemForSorting {
 	path: string
-	groupIdx: number  // the index itself represents order for groups
+	groupIdx?: number  // the index itself represents order for groups
 	sortString: string // fragment (or full name) to be used for sorting
 	matchGroup?: string // advanced - used for secondary sorting rule, to recognize 'same regex match'
 	ctime: number
@@ -38,15 +33,22 @@ let Sorters: { [key in CustomSortOrder]: SorterFn } = {
 };
 
 function compareTwoItems(itA: FolderItemForSorting, itB: FolderItemForSorting, sortSpec: CustomSortSpec) {
-	if (itA.groupIdx === itB.groupIdx) {
-		const group: CustomSortGroup = sortSpec.groups[itA.groupIdx]
-		if (group.regexSpec && group.secondaryOrder && itA.matchGroup === itB.matchGroup) {
-			return Sorters[group.secondaryOrder](itA, itB)
+	if (itA.groupIdx != undefined && itB.groupIdx != undefined) {
+		if (itA.groupIdx === itB.groupIdx) {
+			const group: CustomSortGroup | undefined = sortSpec.groups[itA.groupIdx]
+			if (group?.regexSpec && group.secondaryOrder && itA.matchGroup === itB.matchGroup) {
+				return Sorters[group.secondaryOrder ?? CustomSortOrder.default](itA, itB)
+			} else {
+				return Sorters[group?.order ?? CustomSortOrder.default](itA, itB)
+			}
 		} else {
-			return Sorters[group.order](itA, itB)
+			return itA.groupIdx - itB.groupIdx;
 		}
 	} else {
-		return itA.groupIdx - itB.groupIdx;
+		// should never happen - groupIdx is not known for at least one of items to compare.
+		// The logic of determining the index always sets some idx
+		// Yet for sanity and to satisfy TS code analyzer a fallback to default behavior below
+		return Sorters[CustomSortOrder.default](itA, itB)
 	}
 }
 
@@ -58,7 +60,7 @@ const isFolder = (entry: TFile | TFolder) => {
 export const determineSortingGroup = function (entry: TFile | TFolder, spec: CustomSortSpec): FolderItemForSorting {
 	let groupIdx: number
 	let determined: boolean = false
-	let matchedGroup: string
+	let matchedGroup: string | null | undefined
 	const aFolder: boolean = isFolder(entry)
 	const aFile: boolean = !aFolder
 	const entryAsTFile: TFile = entry as TFile
@@ -77,10 +79,10 @@ export const determineSortingGroup = function (entry: TFile | TFolder, spec: Cus
 						determined = true;
 					}
 				} else { // regexp is involved
-					const match: RegExpMatchArray = group.regexSpec.regex.exec(nameForMatching);
+					const match: RegExpMatchArray | null | undefined = group.regexSpec?.regex.exec(nameForMatching);
 					if (match) {
 						determined = true
-						matchedGroup = group.regexSpec.normalizerFn(match[1]);
+						matchedGroup = group.regexSpec?.normalizerFn(match[1]);
 					}
 				}
 				break;
@@ -90,10 +92,10 @@ export const determineSortingGroup = function (entry: TFile | TFolder, spec: Cus
 						determined = true;
 					}
 				} else { // regexp is involved
-					const match: RegExpMatchArray = group.regexSpec.regex.exec(nameForMatching);
+					const match: RegExpMatchArray | null | undefined = group.regexSpec?.regex.exec(nameForMatching);
 					if (match) {
 						determined = true
-						matchedGroup = group.regexSpec.normalizerFn(match[1]);
+						matchedGroup = group.regexSpec?.normalizerFn(match[1]);
 					}
 				}
 				break;
@@ -107,10 +109,10 @@ export const determineSortingGroup = function (entry: TFile | TFolder, spec: Cus
 				} else { // regexp is involved as the prefix or as the suffix
 					if ((group.exactPrefix && nameForMatching.startsWith(group.exactPrefix)) ||
 						(group.exactSuffix && nameForMatching.endsWith(group.exactSuffix))) {
-						const match: RegExpMatchArray = group.regexSpec.regex.exec(nameForMatching);
+						const match: RegExpMatchArray | null | undefined = group.regexSpec?.regex.exec(nameForMatching);
 						if (match) {
 							const fullMatch: string = match[0]
-							matchedGroup = group.regexSpec.normalizerFn(match[1]);
+							matchedGroup = group.regexSpec?.normalizerFn(match[1]);
 							// check for overlapping of prefix and suffix match (not allowed)
 							if ((fullMatch.length + (group.exactPrefix?.length ?? 0) + (group.exactSuffix?.length ?? 0)) <= nameForMatching.length) {
 								determined = true
@@ -127,10 +129,10 @@ export const determineSortingGroup = function (entry: TFile | TFolder, spec: Cus
 						determined = true;
 					}
 				} else { // regexp is involved
-					const match: RegExpMatchArray = group.regexSpec.regex.exec(nameForMatching);
+					const match: RegExpMatchArray | null | undefined = group.regexSpec?.regex.exec(nameForMatching);
 					if (match) {
 						determined = true
-						matchedGroup = group.regexSpec.normalizerFn(match[1]);
+						matchedGroup = group.regexSpec?.normalizerFn(match[1]);
 					}
 				}
 				break;
@@ -144,7 +146,7 @@ export const determineSortingGroup = function (entry: TFile | TFolder, spec: Cus
 	}
 
 	// the final groupIdx for undetermined folder entry is either the last+1 groupIdx or idx of explicitly defined outsiders group
-	let determinedGroupIdx = groupIdx;
+	let determinedGroupIdx: number | undefined = groupIdx;
 
 	if (!determined) {
 		// Automatically assign the index to outsiders group, if relevant was configured
@@ -174,7 +176,7 @@ export const folderSort = function (sortingSpec: CustomSortSpec, order: string[]
 
 	const folderItems: Array<FolderItemForSorting> = (sortingSpec.itemsToHide ?
 		this.file.children.filter((entry: TFile | TFolder) => {
-			return !sortingSpec.itemsToHide.has(entry.name)
+			return !sortingSpec.itemsToHide!.has(entry.name)
 		})
 		:
 		this.file.children)

src/custom-sort/folder-matching-rules.spec.ts

@@ -58,18 +58,18 @@ describe('folderMatch', () => {
 		['Reviews/daily/a/Tue/Early/9am', '4 Reviews/daily/a/*']
 	])('%s should match %s', (path: string, rule: string) => {
 		const matcher: FolderWildcardMatching<SortingSpec> = createMockMatcherRichVersion()
-		const match: SortingSpec = matcher.folderMatch(path)
-		const matchFromCache: SortingSpec = matcher.folderMatch(path)
+		const match: SortingSpec | null = matcher.folderMatch(path)
+		const matchFromCache: SortingSpec | null = matcher.folderMatch(path)
 		expect(match).toBe(rule)
 		expect(matchFromCache).toBe(rule)
 	})
 	it('should correctly handle no-root definitions', () => {
 		const matcher: FolderWildcardMatching<SortingSpec> = createMockMatcherSimplestVersion()
-		const match1: SortingSpec = matcher.folderMatch('/')
-		const match2: SortingSpec = matcher.folderMatch('/Reviews')
-		const match3: SortingSpec = matcher.folderMatch('/Reviews/daily/')
-		const match4: SortingSpec = matcher.folderMatch('/Reviews/daily/Mon')
-		const match5: SortingSpec = matcher.folderMatch('/Reviews/daily/Mon')
+		const match1: SortingSpec | null = matcher.folderMatch('/')
+		const match2: SortingSpec | null = matcher.folderMatch('/Reviews')
+		const match3: SortingSpec | null = matcher.folderMatch('/Reviews/daily/')
+		const match4: SortingSpec | null = matcher.folderMatch('/Reviews/daily/Mon')
+		const match5: SortingSpec | null = matcher.folderMatch('/Reviews/daily/Mon')
 		expect(match1).toBeNull()
 		expect(match2).toBeNull()
 		expect(match3).toBe('/Reviews/daily/*')
@@ -78,27 +78,27 @@ describe('folderMatch', () => {
 	})
 	it('should correctly handle root-only definition', () => {
 		const matcher: FolderWildcardMatching<SortingSpec> = createMockMatcherRootOnlyVersion()
-		const match1: SortingSpec = matcher.folderMatch('/')
-		const match2: SortingSpec = matcher.folderMatch('/Reviews')
-		const match3: SortingSpec = matcher.folderMatch('/Reviews/daily/')
+		const match1: SortingSpec | null = matcher.folderMatch('/')
+		const match2: SortingSpec | null = matcher.folderMatch('/Reviews')
+		const match3: SortingSpec | null = matcher.folderMatch('/Reviews/daily/')
 		expect(match1).toBe('/...')
 		expect(match2).toBe('/...')
 		expect(match3).toBeNull()
 	})
 	it('should correctly handle root-only deep definition', () => {
 		const matcher: FolderWildcardMatching<SortingSpec> = createMockMatcherRootOnlyDeepVersion()
-		const match1: SortingSpec = matcher.folderMatch('/')
-		const match2: SortingSpec = matcher.folderMatch('/Reviews')
-		const match3: SortingSpec = matcher.folderMatch('/Reviews/daily/')
+		const match1: SortingSpec | null = matcher.folderMatch('/')
+		const match2: SortingSpec | null = matcher.folderMatch('/Reviews')
+		const match3: SortingSpec | null = matcher.folderMatch('/Reviews/daily/')
 		expect(match1).toBe('/*')
 		expect(match2).toBe('/*')
 		expect(match3).toBe('/*')
 	})
 	it('should correctly handle match all and match children definitions for same path', () => {
 		const matcher: FolderWildcardMatching<SortingSpec> = createMockMatcherSimpleVersion()
-		const match1: SortingSpec = matcher.folderMatch('/')
-		const match2: SortingSpec = matcher.folderMatch('/Reviews/daily/')
-		const match3: SortingSpec = matcher.folderMatch('/Reviews/daily/1')
+		const match1: SortingSpec | null = matcher.folderMatch('/')
+		const match2: SortingSpec | null = matcher.folderMatch('/Reviews/daily/')
+		const match3: SortingSpec | null = matcher.folderMatch('/Reviews/daily/1')
 		expect(match1).toBeNull()
 		expect(match2).toBe('/Reviews/daily/...')
 		expect(match3).toBe('/Reviews/daily/...')

src/custom-sort/folder-matching-rules.ts

@@ -41,9 +41,9 @@ export class FolderWildcardMatching<SortingSpec> {
 	// cache
 	determinedWildcardRules: { [key: string]: DeterminedSortingSpec<SortingSpec> } = {}
 
-	addWildcardDefinition = (wilcardDefinition: string, rule: SortingSpec): AddingWildcardFailure | null => {
+	addWildcardDefinition = (wilcardDefinition: string, rule: SortingSpec): AddingWildcardFailure | null | undefined => {
 		const pathComponents: Array<string> = splitPath(wilcardDefinition)
-		const lastComponent: string = pathComponents.pop()
+		const lastComponent: string | undefined = pathComponents.pop()
 		if (lastComponent !== MATCH_ALL_PATH_TOKEN && lastComponent !== MATCH_CHILDREN_PATH_TOKEN) {
 			return null
 		}
@@ -82,8 +82,8 @@ export class FolderWildcardMatching<SortingSpec> {
 		if (spec) {
 			return spec.spec ?? null
 		} else {
-			let rule: SortingSpec = this.tree.matchChildren
-			let inheritedRule: SortingSpec = this.tree.matchAll
+			let rule: SortingSpec | null | undefined = this.tree.matchChildren
+			let inheritedRule: SortingSpec | undefined = this.tree.matchAll
 			const pathComponents: Array<string> = splitPath(folderPath)
 			let parentNode: FolderMatchingTreeNode<SortingSpec> = this.tree
 			let lastIdx: number = pathComponents.length - 1

src/custom-sort/matchers.spec.ts

@@ -26,7 +26,7 @@ describe('Plain numbers regexp', () => {
 		const match: RegExpMatchArray | null = s.match(NumberRegex)
 		if (out) {
 			expect(match).not.toBeNull()
-			expect(match[1]).toBe(out)
+			expect(match?.[1]).toBe(out)
 		} else {
 			expect(match).toBeNull()
 		}
@@ -58,7 +58,7 @@ describe('Plain compound numbers regexp (dot)', () => {
 		const match: RegExpMatchArray | null = s.match(CompoundNumberDotRegex)
 		if (out) {
 			expect(match).not.toBeNull()
-			expect(match[1]).toBe(out)
+			expect(match?.[1]).toBe(out)
 		} else {
 			expect(match).toBeNull()
 		}
@@ -90,7 +90,7 @@ describe('Plain compound numbers regexp (dash)', () => {
 		const match: RegExpMatchArray | null = s.match(CompoundNumberDashRegex)
 		if (out) {
 			expect(match).not.toBeNull()
-			expect(match[1]).toBe(out)
+			expect(match?.[1]).toBe(out)
 		} else {
 			expect(match).toBeNull()
 		}
@@ -112,7 +112,7 @@ describe('Plain Roman numbers regexp', () => {
 		const match: RegExpMatchArray | null = s.match(RomanNumberRegex)
 		if (out) {
 			expect(match).not.toBeNull()
-			expect(match[1]).toBe(out)
+			expect(match?.[1]).toBe(out)
 		} else {
 			expect(match).toBeNull()
 		}
@@ -146,7 +146,7 @@ describe('Roman compound numbers regexp (dot)', () => {
 		const match: RegExpMatchArray | null = s.match(CompoundRomanNumberDotRegex)
 		if (out) {
 			expect(match).not.toBeNull()
-			expect(match[1]).toBe(out)
+			expect(match?.[1]).toBe(out)
 		} else {
 			expect(match).toBeNull()
 		}
@@ -180,7 +180,7 @@ describe('Roman compound numbers regexp (dash)', () => {
 		const match: RegExpMatchArray | null = s.match(CompoundRomanNumberDashRegex)
 		if (out) {
 			expect(match).not.toBeNull()
-			expect(match[1]).toBe(out)
+			expect(match?.[1]).toBe(out)
 		} else {
 			expect(match).toBeNull()
 		}