refactor: Get rid of openTextDocument in extractDanglingRefs util

src/features/fsWatcher.ts

@@ -36,7 +36,7 @@ const textDocumentChangeListener = async (event: TextDocumentChangeEvent) => {
  }
 };
 
-const textDocumentChangeListenerDebounced = debounce(textDocumentChangeListener, 100);
+const textDocumentChangeListenerDebounced = debounce(textDocumentChangeListener, 500);
 
 export const activate = (context: ExtensionContext) => {
  const fileWatcher = workspace.createFileSystemWatcher(`**/*`);

src/utils/utils.spec.ts

@@ -1,4 +1,4 @@
-import { window, Selection, workspace, Position, Uri } from 'vscode';
+import { window, Selection, workspace, Range, Position, Uri } from 'vscode';
 import fs from 'fs';
 import path from 'path';
 
@@ -1345,10 +1345,8 @@ describe('extractDanglingRefs()', () => {
  await createFile(`${name0}.md`);
 
  expect(
- await extractDanglingRefs(
- await workspace.openTextDocument({
- language: 'markdown',
- content: `
+ extractDanglingRefs(
+ `
  [[dangling-ref]]
  [[dangling-ref]]
  [[dangling-ref2|Test Label]]
@@ -1362,7 +1360,6 @@ describe('extractDanglingRefs()', () => {
  \`\`\`
  [[${name0}]]
  `,
- }),
  ),
  ).toEqual(['dangling-ref', 'dangling-ref2', 'folder1/long-dangling-ref', 'dangling-ref3']);
  });
@@ -1406,4 +1403,30 @@ describe('findDanglingRefsByFsPath()', () => {
  'dangling-ref3',
  ]);
  });
+
+ it('should find dangling refs from the just edited document', async () => {
+ const name0 = rndName();
+
+ await createFile(`${name0}.md`, '[[dangling-ref]]');
+
+ const doc = await openTextDocument(`${name0}.md`);
+
+ const editor = await window.showTextDocument(doc);
+
+ const refsByFsPath = await findDanglingRefsByFsPath(getWorkspaceCache().markdownUris);
+
+ expect(Object.keys(refsByFsPath)).toHaveLength(1);
+ expect(Object.values(refsByFsPath)[0]).toEqual(['dangling-ref']);
+
+ await editor.edit((edit) => edit.insert(new Position(1, 0), '[[dangling-ref2]]'));
+
+ const refsByFsPath2 = await findDanglingRefsByFsPath(getWorkspaceCache().markdownUris);
+
+ expect(Object.keys(refsByFsPath2)).toHaveLength(1);
+ expect(Object.values(refsByFsPath2)[0]).toEqual(['dangling-ref', 'dangling-ref2']);
+
+ await editor.edit((edit) => edit.delete(new Range(new Position(0, 0), new Position(2, 0))));
+
+ expect(await findDanglingRefsByFsPath(getWorkspaceCache().markdownUris)).toEqual({});
+ });
 });

src/utils/utils.ts

@@ -92,37 +92,31 @@ export const fsPathToRef = ({
  return trimLeadingSlash(ref.includes('.') ? ref.slice(0, ref.lastIndexOf('.')) : ref);
 };
 
-export const extractDanglingRefs = async (document: vscode.TextDocument) => {
- const matches = matchAll(new RegExp(refPattern, 'gi'), document.getText());
-
- if (matches.length) {
- const refs = matches.reduce<string[]>((refs, match) => {
- const [, , $2] = match;
- const offset = (match.index || 0) + 2;
-
- const refStart = document.positionAt(offset);
- const lineStart = document.lineAt(refStart);
-
- if (
- isInFencedCodeBlock(document, lineStart.lineNumber) ||
- isInCodeSpan(document, lineStart.lineNumber, refStart.character)
- ) {
- return refs;
- }
+const refRegexp = new RegExp(refPattern, 'gi');
 
- const { ref } = parseRef($2);
+export const extractDanglingRefs = (content: string) => {
+ const refs: string[] = [];
 
- if (!findUriByRef(getWorkspaceCache().allUris, ref)) {
- refs.push(ref);
- }
+ content.split(/\r?\n/g).forEach((lineText, lineNum) => {
+ for (const match of matchAll(refRegexp, lineText)) {
+ const [, , reference] = match;
+ if (reference) {
+ const offset = (match.index || 0) + 2;
 
- return refs;
- }, []);
+ if (isInFencedCodeBlock(content, lineNum) || isInCodeSpan(content, lineNum, offset)) {
+ continue;
+ }
 
- return Array.from(new Set(refs));
- }
+ const { ref } = parseRef(reference);
 
- return [];
+ if (!findUriByRef(getWorkspaceCache().allUris, ref)) {
+ refs.push(ref);
+ }
+ }
+ }
+ });
+
+ return Array.from(new Set(refs));
 };
 
 export const findDanglingRefsByFsPath = async (uris: vscode.Uri[]) => {
@@ -138,9 +132,8 @@ export const findDanglingRefsByFsPath = async (uris: vscode.Uri[]) => {
  continue;
  }
 
- const refs = await extractDanglingRefs(
- await vscode.workspace.openTextDocument(vscode.Uri.file(fsPath)),
- );
+ const doc = workspace.textDocuments.find((doc) => doc.uri.fsPath === fsPath);
+ const refs = extractDanglingRefs(doc ? doc.getText() : fs.readFileSync(fsPath).toString());
 
  if (refs.length) {
  refsByFsPath[fsPath] = refs;