yanki 2.0.11 → 2.0.12

package/dist/lib/index.js

@@ -509,7 +509,7 @@ function getFileExtensionForMimeType(mimeType) {
 //#endregion
 //#region src/lib/utilities/path.ts
 const WINDOWS_DRIVE_LETTER_REGEX = /* @__PURE__ */ new RegExp("^[A-Z]:", "iv");
-const QUERY_FRAGMENT_START_REGEX = /* @__PURE__ */ new RegExp("[#?^]", "v");
+const QUERY_FRAGMENT_START_REGEX = /* @__PURE__ */ new RegExp("[#^]", "v");
 /**
 * The browserify polyfill doesn't implement win32 absolute path detection...
 *
@@ -575,26 +575,37 @@ function getBaseAndQueryParts(filePath) {
 	const [base, query] = splitAtFirstMatch(path.basename(filePath), QUERY_FRAGMENT_START_REGEX);
 	return [path.join(directoryPath, base), query];
 }
+/**
+* Get every plausible base and anchor interpretation of a file path whose name
+* may contain anchor delimiter characters (`#`, `^`), ordered from the longest
+* literal file name (no anchor at all) to the shortest (anchor starts at the
+* first delimiter in the file name, matching Obsidian's anchor syntax).
+* Delimiters in directory names are never treated as anchor starts.
+*
+* File names may legitimately contain these characters, so callers should try
+* candidates in order against a list of real files instead of assuming the
+* first delimiter starts an anchor.
+* https://github.com/kitschpatrol/yanki/issues/20
+*/
+function getBaseAndQueryCandidates(filePath) {
+	const directoryPath = path.dirname(filePath);
+	const fileName = path.basename(filePath);
+	const candidates = [{
+		base: path.join(directoryPath, fileName),
+		query: void 0
+	}];
+	for (let index = fileName.length - 1; index >= 0; index--) if (QUERY_FRAGMENT_START_REGEX.test(fileName.charAt(index))) candidates.push({
+		base: path.join(directoryPath, fileName.slice(0, index)),
+		query: fileName.slice(index)
+	});
+	return candidates;
+}
 function getBase(filePath) {
 	return getBaseAndQueryParts(filePath)[0];
 }
 function getQuery(filePath) {
 	return getBaseAndQueryParts(filePath).at(1) ?? "";
 }
-function hasExtension(filePath) {
-	return getExtension(filePath) !== "";
-}
-function getExtension(filePath) {
-	return path.extname(getBase(filePath));
-}
-function addExtensionIfMissing(filePath, extension) {
-	if (hasExtension(filePath)) return filePath;
-	return addExtension(filePath, extension);
-}
-function addExtension(filePath, extension) {
-	const [base, query] = getBaseAndQueryParts(filePath);
-	return `${base}.${extension}${query ?? ""}`;
-}
 //#endregion
 //#region src/lib/utilities/url.ts
 const DRIVE_LETTER_REGEX = /* @__PURE__ */ new RegExp("^[a-z]:", "iv");
@@ -1792,7 +1803,9 @@ const defaultResolveLinkOptions = {
 * @returns Resolved absolute path or URL One of:
 *
 *   - Resolved absolute POSIX-style paths
-*   - Removes any file path query parameters
+*   - Removes any Obsidian-style heading and block anchors, unless the anchor
+*       characters are a literal part of a matched file's name (`?` is always
+*       treated as a literal file name character in local paths)
 *   - Not URI-encoded
 *   - Retains original case
 *   - HTTP protocol URL
@@ -1807,8 +1820,7 @@ function resolveLink(filePathOrUrl, options) {
 		const decodedUrl = safeDecodeURI(currentPathOrUrl) ?? currentPathOrUrl;
 		const sourceType = getSrcType(decodedUrl);
 		if (sourceType === "localFileName") {
-			let resolvedUrl = addExtensionIfMissing(normalize(decodedUrl), "md");
-			resolvedUrl = resolveNameLink(resolvedUrl, cwd, allFilePaths ?? []) ?? resolveWithBasePath(decodedUrl, {
+			const resolvedUrl = resolveNameLink(normalize(decodedUrl), cwd, allFilePaths ?? []) ?? resolveWithBasePath(decodedUrl, {
 				basePath,
 				cwd
 			});
@@ -1856,13 +1868,21 @@ function resolveLocalFilePath(decodedUrl, options) {
 		basePath,
 		cwd
 	});
-	const resolvedUrlWithMatchedExtension = pathExistsInAllFiles(addExtensionIfMissing(resolvedUrl, "md"), allFilePaths ?? []) ?? pathExistsInAllFiles(addExtension(resolvedUrl, "md"), allFilePaths ?? []) ?? void 0;
-	if (resolvedUrlWithMatchedExtension !== void 0) {
-		if (convertFilePathsToProtocol !== "none" && (type === "link" || type === "embed" && [".md", ".pdf"].includes(getExtension(resolvedUrlWithMatchedExtension)))) {
-			if (convertFilePathsToProtocol === "obsidian" && obsidianVaultName !== void 0) return createObsidianVaultLink(resolvedUrlWithMatchedExtension, basePath ?? "", obsidianVaultName);
-			if (convertFilePathsToProtocol === "file") return createFileLink(resolvedUrlWithMatchedExtension);
+	let matchedPath;
+	let matchedQuery;
+	for (const { base, query } of getBaseAndQueryCandidates(resolvedUrl)) {
+		matchedPath = (path.extname(base) === "" ? [`${base}.md`] : [base, `${base}.md`]).find((candidate) => pathExistsInAllFiles(candidate, allFilePaths ?? []));
+		if (matchedPath !== void 0) {
+			matchedQuery = query;
+			break;
+		}
+	}
+	if (matchedPath !== void 0) {
+		if (convertFilePathsToProtocol !== "none" && (type === "link" || type === "embed" && [".md", ".pdf"].includes(path.extname(matchedPath)))) {
+			if (convertFilePathsToProtocol === "obsidian" && obsidianVaultName !== void 0) return createObsidianVaultLink(`${matchedPath}${matchedQuery ?? ""}`, basePath ?? "", obsidianVaultName);
+			if (convertFilePathsToProtocol === "file") return createFileLink(`${matchedPath}${matchedQuery ?? ""}`);
 		}
-		return getBase(resolvedUrlWithMatchedExtension);
+		return matchedPath;
 	}
 	return getBase(resolvedUrl);
 }
@@ -1875,9 +1895,10 @@ function resolveLocalFilePath(decodedUrl, options) {
 * Obsidian seems to treat note links slightly differently from image / asset
 * links.
 *
-* @param name Non-URI-encoded name of the file, may have file extension, if no
-*   match with a non-.md extension is found, a match will be attempted with .md
-*   regardless. (POSIX-style paths.)
+* @param name Non-URI-encoded, normalized name of the file, with or without a
+*   file extension. Extension-less names are assumed to be .md files. May
+*   include an anchor suffix, or anchor delimiter characters that are a literal
+*   part of the file name. (POSIX-style paths.)
 * @param cwd Absolute path to the current working directory of the file from
 *   which we're resolving the link. (POSIX-style paths)
 * @param allFilePaths Array of absolute paths to all other files in the paths
@@ -1888,14 +1909,34 @@ function resolveLocalFilePath(decodedUrl, options) {
 */
 function resolveNameLink(name, cwd, allFilePaths) {
 	if (allFilePaths.length === 0) return;
-	const [base, query] = getBaseAndQueryParts(name);
+	for (const { base, query } of getBaseAndQueryCandidates(name)) {
+		const match = findBestNameMatch(path.extname(base) === "" ? `${base}.md` : base, cwd, allFilePaths);
+		if (match !== void 0) return `${match}${query ?? ""}`;
+	}
+}
+/**
+* Find the best matching file for a name in the list of all file paths.
+* Extracted from `resolveNameLink` so each base and anchor interpretation of
+* the name can be attempted in turn.
+*
+* @param base Non-URI-encoded name of the file with a file extension and no
+*   anchor suffix. (POSIX-style paths.)
+* @param cwd Absolute path to the current working directory of the file from
+*   which we're resolving the link. (POSIX-style paths)
+* @param allFilePaths Array of absolute paths to all other files in the paths
+*   to be considered. (POSIX-style paths.)
+*
+* @returns Absolute path to the best matching file, or undefined if there's no
+*   valid match. (POSIX-style paths.)
+*/
+function findBestNameMatch(base, cwd, allFilePaths) {
 	const baseWithoutMd = base.replace(MD_EXTENSION_REGEX, "").toLowerCase();
 	const pathsToName = allFilePaths.filter((filePath) => {
 		return filePath.replace(MD_EXTENSION_REGEX, "").toLowerCase().endsWith(baseWithoutMd);
 	});
 	if (pathsToName.length === 0) return;
-	if (pathsToName.length === 1) return `${pathsToName[0]}${query ?? ""}`;
-	return `${pathsToName.toSorted((a, b) => {
+	if (pathsToName.length === 1) return pathsToName[0];
+	return pathsToName.toSorted((a, b) => {
 		if (!base.endsWith(".md") || base.includes(path.sep)) {
 			const aHasCwd = a.startsWith(cwd);
 			if (aHasCwd !== b.startsWith(cwd)) return aHasCwd ? -1 : 1;
@@ -1904,22 +1945,22 @@ function resolveNameLink(name, cwd, allFilePaths) {
 		const bDepth = b.split(path.sep).length;
 		if (aDepth !== bDepth) return aDepth - bDepth;
 		return a.localeCompare(b);
-	})[0]}${query ?? ""}`;
+	})[0];
 }
 /**
-* Check for presence of a path in a list in a case- and query- agnostic manner.
-* Ignores .md extensions to simplify matching files
+* Check for presence of a path in a list in a case-agnostic manner, since
+* Obsidian is not case sensitive.
 *
-* @param filePath File path with file extension. (POSIX-style path.)
+* @param filePath Literal file path with file extension and no anchor suffix.
+*   (POSIX-style path.)
 * @param allFilePaths Array of absolute file paths to check. (POSIX-style
 *   paths.)
 *
-* @returns The file path if it is present in the list of all file paths, or
-*   undefined if it is not.
+* @returns Whether the file path is present in the list of all file paths.
 */
 function pathExistsInAllFiles(filePath, allFilePaths) {
-	const base = getBase(filePath);
-	if (allFilePaths.some((file) => file.toLowerCase().endsWith(base.toLowerCase()))) return filePath;
+	const filePathLowerCase = filePath.toLowerCase();
+	return allFilePaths.some((file) => file.toLowerCase().endsWith(filePathLowerCase));
 }
 function createFileLink(absolutePath) {
 	return `file://${absolutePath}`;
@@ -1948,7 +1989,7 @@ const plugin$1 = function(options) {
 				obsidianVaultName: obsidianVault,
 				type: "link"
 			});
-			node.url = isUrl(resolvedLink) ? resolvedLink : encodeURI(resolvedLink);
+			node.url = isUrl(resolvedLink) ? resolvedLink : encodeURI(resolvedLink).replaceAll("?", "%3F").replaceAll("#", "%23");
 		});
 		visit(tree, "image", (node) => {
 			node.data ??= {};