yanki 2.0.11 → 2.0.13

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,36 @@ 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 local link target
+* that may contain anchor delimiter characters (`#`, `^`), ordered from the
+* longest literal path (no anchor at all) to the shortest (anchor starts at the
+* first delimiter, matching Obsidian's anchor syntax).
+*
+* This operates on the unnormalized link target and deliberately considers
+* delimiters before slashes. A slash after a delimiter belongs to the anchor,
+* not the file path. File and directory names may also legitimately contain
+* these characters, so callers must normalize only each candidate's `filePath`
+* and try candidates in order against a list of real files.
+* https://github.com/kitschpatrol/yanki/issues/20
+*/
+function getLocalPathCandidates(linkTarget) {
+	const candidates = [{
+		anchor: void 0,
+		filePath: linkTarget
+	}];
+	for (let index = linkTarget.length - 1; index >= 0; index--) if (QUERY_FRAGMENT_START_REGEX.test(linkTarget.charAt(index))) candidates.push({
+		anchor: linkTarget.slice(index),
+		filePath: linkTarget.slice(0, 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 +1802,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
@@ -1800,49 +1812,25 @@ const defaultResolveLinkOptions = {
 *       parameters)
 */
 function resolveLink(filePathOrUrl, options) {
-	const { allFilePaths, basePath, convertFilePathsToProtocol, cwd, obsidianVaultName, type } = deepmerge(defaultResolveLinkOptions, options ?? {});
+	const resolvedOptions = deepmerge(defaultResolveLinkOptions, options ?? {});
+	const { allFilePaths, convertFilePathsToProtocol, cwd, obsidianVaultName } = resolvedOptions;
 	if (convertFilePathsToProtocol === "obsidian" && obsidianVaultName === void 0) console.warn(`convertFilePathsToProtocol is 'obsidian', but no obsidianVaultName provided`);
-	let currentPathOrUrl = filePathOrUrl;
-	for (;;) {
-		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, {
-				basePath,
-				cwd
-			});
-			if (getSrcType(resolvedUrl) === "localFilePath") {
-				currentPathOrUrl = resolvedUrl;
-				continue;
-			}
-			console.warn(`Failed to convert local file wiki-style name to path: ${currentPathOrUrl} --> ${resolvedUrl}`);
-			return resolvedUrl;
+	const decodedUrl = safeDecodeURI(filePathOrUrl) ?? filePathOrUrl;
+	switch (getSrcType(decodedUrl)) {
+		case "localFileName": {
+			const resolvedNameLink = resolveNameLink(decodedUrl, cwd, allFilePaths ?? []);
+			return resolvedNameLink === void 0 ? resolveLocalFilePath(decodedUrl, resolvedOptions) : resolveMatchedLocalLink(resolvedNameLink, resolvedOptions);
 		}
-		if (sourceType === "localFileUrl") {
-			const resolvedUrl = normalize(fileUrlToPath(currentPathOrUrl));
-			if (getSrcType(resolvedUrl) === "localFilePath") {
-				currentPathOrUrl = resolvedUrl;
-				continue;
-			}
-			console.warn(`Failed to convert file URL to path: ${currentPathOrUrl} --> ${resolvedUrl}`);
-			return resolvedUrl;
-		}
-		switch (sourceType) {
-			case "localFilePath": return resolveLocalFilePath(decodedUrl, {
-				allFilePaths,
-				basePath,
-				convertFilePathsToProtocol,
-				cwd,
-				obsidianVaultName,
-				type
-			});
-			case "obsidianVaultUrl": return currentPathOrUrl;
-			case "remoteHttpUrl": return currentPathOrUrl;
-			case "unsupportedProtocolUrl":
-				console.warn(`Unsupported URL protocol: ${currentPathOrUrl}`);
-				return currentPathOrUrl;
+		case "localFilePath": return resolveLocalFilePath(decodedUrl, resolvedOptions);
+		case "localFileUrl": {
+			const encodedFilePath = fileUrlToPath(filePathOrUrl);
+			return resolveLocalFilePath(safeDecodeURI(encodedFilePath) ?? encodedFilePath, resolvedOptions);
 		}
+		case "obsidianVaultUrl":
+		case "remoteHttpUrl": return filePathOrUrl;
+		case "unsupportedProtocolUrl":
+			console.warn(`Unsupported URL protocol: ${filePathOrUrl}`);
+			return filePathOrUrl;
 	}
 }
 /**
@@ -1851,20 +1839,33 @@ function resolveLink(filePathOrUrl, options) {
 * `max-depth` lint rule).
 */
 function resolveLocalFilePath(decodedUrl, options) {
-	const { allFilePaths, basePath, convertFilePathsToProtocol, cwd, obsidianVaultName, type } = options;
-	const resolvedUrl = resolveWithBasePath(normalize(decodedUrl), {
+	const { allFilePaths, basePath, cwd } = options;
+	const candidates = getLocalPathCandidates(decodedUrl);
+	for (const { anchor, filePath } of candidates) {
+		const resolvedBase = resolveWithBasePath(normalize(filePath), {
+			basePath,
+			cwd
+		});
+		const matchedPath = (path.extname(resolvedBase) === "" ? [`${resolvedBase}.md`] : [resolvedBase, `${resolvedBase}.md`]).find((candidate) => pathExistsInAllFiles(candidate, allFilePaths ?? []));
+		if (matchedPath !== void 0) return resolveMatchedLocalLink({
+			anchor,
+			filePath: matchedPath
+		}, options);
+	}
+	return resolveWithBasePath(normalize(candidates.at(-1)?.filePath ?? decodedUrl), {
 		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);
-		}
-		return getBase(resolvedUrlWithMatchedExtension);
+}
+/** Render a matched local file and its still-unmodified Obsidian anchor. */
+function resolveMatchedLocalLink(link, options) {
+	const { anchor, filePath } = link;
+	const { basePath, convertFilePathsToProtocol, obsidianVaultName, type } = options;
+	if (convertFilePathsToProtocol !== "none" && (type === "link" || type === "embed" && [".md", ".pdf"].includes(path.extname(filePath)))) {
+		if (convertFilePathsToProtocol === "obsidian" && obsidianVaultName !== void 0) return createObsidianVaultLink(link, basePath ?? "", obsidianVaultName);
+		if (convertFilePathsToProtocol === "file") return createFileLink(`${filePath}${anchor ?? ""}`);
 	}
-	return getBase(resolvedUrl);
+	return filePath;
 }
 /**
 * Convert from a (usually wiki-style) named link to an absolute path to an
@@ -1875,27 +1876,52 @@ 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
 *   to be considered. (POSIX-style paths.)
 *
-* @returns Absolute path to the best matching file with the name provided, or
-*   undefined if there's no valid match. (POSIX-style paths.)
+* @returns The absolute path to the best matching file and its unmodified
+*   anchor, or undefined if there's no valid match. (POSIX-style path.)
 */
 function resolveNameLink(name, cwd, allFilePaths) {
 	if (allFilePaths.length === 0) return;
-	const [base, query] = getBaseAndQueryParts(name);
+	for (const { anchor, filePath } of getLocalPathCandidates(name)) {
+		const normalizedBase = normalize(filePath);
+		const match = findBestNameMatch(path.extname(normalizedBase) === "" ? `${normalizedBase}.md` : normalizedBase, cwd, allFilePaths);
+		if (match !== void 0) return {
+			anchor,
+			filePath: match
+		};
+	}
+}
+/**
+* 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,29 +1930,29 @@ 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}`;
 }
-function createObsidianVaultLink(absolutePath, basePath, obsidianVault) {
-	const relativePath = stripBasePath(absolutePath, basePath);
-	return `obsidian://open?vault=${encodeURIComponent(obsidianVault)}&file=${encodeURIComponent(relativePath)}`;
+function createObsidianVaultLink(link, basePath, obsidianVault) {
+	const linkPath = `${stripBasePath(link.filePath, basePath)}${link.anchor ?? ""}`;
+	return `obsidian://open?vault=${encodeURIComponent(obsidianVault)}&file=${encodeURIComponent(linkPath)}`;
 }
 //#endregion
 //#region src/lib/parse/remark-resolve-links.ts
@@ -1948,7 +1974,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 ??= {};