302 lines
8.0 KiB
TypeScript
302 lines
8.0 KiB
TypeScript
import {
|
|
App,
|
|
Editor,
|
|
EditorPosition,
|
|
EditorSuggest,
|
|
EditorSuggestContext,
|
|
EditorSuggestTriggerInfo,
|
|
TFolder,
|
|
} from "obsidian";
|
|
import { PassageFormat, PassageReference } from "./passage-reference";
|
|
import { LocalBibleRefSettings } from "./settings";
|
|
|
|
export class PassageSuggest extends EditorSuggest<PassageSuggestion> {
|
|
private settings: LocalBibleRefSettings;
|
|
|
|
constructor(app: App, settings: LocalBibleRefSettings) {
|
|
super(app);
|
|
this.settings = settings;
|
|
}
|
|
|
|
onTrigger(
|
|
cursor: EditorPosition,
|
|
editor: Editor,
|
|
_: any
|
|
): EditorSuggestTriggerInfo | null {
|
|
// min ref length is 6 ('--gen1')
|
|
if (cursor.ch < 6) return null;
|
|
|
|
// line must start with '--'
|
|
const line = editor.getLine(cursor.line);
|
|
if (!line.startsWith("--")) return null;
|
|
|
|
// must be a passage ref
|
|
const isPassage = PassageReference.regExp.test(line);
|
|
if (!isPassage) return null;
|
|
|
|
// trigger info
|
|
return {
|
|
end: cursor,
|
|
query: line,
|
|
start: {
|
|
ch: 0,
|
|
line: cursor.line,
|
|
},
|
|
};
|
|
}
|
|
|
|
async getSuggestions(
|
|
context: EditorSuggestContext
|
|
): Promise<PassageSuggestion[]> {
|
|
const passageRef = PassageReference.parse(
|
|
context.query,
|
|
this.settings.defaultVersionShorthand,
|
|
this.settings.defaultPassageFormat,
|
|
);
|
|
if (!passageRef) return [];
|
|
|
|
// grab all chapters in the range
|
|
let texts = await this.getChapterTexts(passageRef);
|
|
if (!texts) return [];
|
|
|
|
// split first chapter by start verse
|
|
const textFromVerse = this.getTextFromStartVerse(
|
|
texts[0],
|
|
passageRef
|
|
);
|
|
if (!textFromVerse) return [];
|
|
texts[0] = textFromVerse;
|
|
|
|
// split last chapter by end verse
|
|
const lastIndex = texts.length - 1;
|
|
const textToVerse = this.getTextToEndVerse(
|
|
texts[lastIndex],
|
|
passageRef
|
|
);
|
|
if (!textToVerse) return [];
|
|
texts[lastIndex] = textToVerse;
|
|
|
|
// clean up chapter texts
|
|
const multipleChapters = texts.length > 1;
|
|
texts = texts.map((text, i) => {
|
|
const chapterNumber = passageRef.startChapter + i;
|
|
return this.cleanText(text, chapterNumber, multipleChapters);
|
|
});
|
|
|
|
// suggest
|
|
const excerpt = this.generateExcerpt(texts[0]);
|
|
const text = this.formatTexts(texts, passageRef, context);
|
|
return [{ excerpt, text }];
|
|
}
|
|
|
|
renderSuggestion(item: PassageSuggestion, el: HTMLElement): void {
|
|
el.innerText = item.excerpt;
|
|
}
|
|
|
|
selectSuggestion(
|
|
item: PassageSuggestion,
|
|
_: MouseEvent | KeyboardEvent
|
|
): void {
|
|
if (!this.context) return;
|
|
this.context.editor.replaceRange(
|
|
item.text,
|
|
this.context.start,
|
|
this.context.end
|
|
);
|
|
}
|
|
|
|
/** Retrieves the texts of the chapters within a passage ref. */
|
|
private async getChapterTexts(
|
|
ref: PassageReference
|
|
): Promise<string[] | null> {
|
|
let basePath = "";
|
|
for (const alias of [ref.book.name, ...ref.book.aliases]) {
|
|
basePath = [this.settings.biblesPath, ref.version, alias].join("/");
|
|
|
|
// if the book exists at this alias, use the alias instead
|
|
// and add the previous book name to the aliases
|
|
if (await this.app.vault.adapter.exists(basePath)) {
|
|
ref.book.aliases.push(ref.book.name);
|
|
ref.book.aliases.remove(alias);
|
|
ref.book.name = alias;
|
|
break;
|
|
}
|
|
}
|
|
|
|
const texts: string[] = [];
|
|
|
|
// collect chapter texts
|
|
for (let ch = ref.startChapter; ch <= ref.endChapter; ch++) {
|
|
const path = basePath + `/${ref.book.name} ${ch}.md`;
|
|
const file = this.app.vault.getFileByPath(path);
|
|
if (!file) return null;
|
|
|
|
texts.push(await this.app.vault.cachedRead(file));
|
|
}
|
|
|
|
return texts;
|
|
}
|
|
|
|
/** Extracts the text in the chapter from the start verse to the end. */
|
|
private getTextFromStartVerse(
|
|
text: string,
|
|
ref: PassageReference
|
|
): string | null {
|
|
const regExp = new RegExp(
|
|
`(?:[>-] )*(?:\\*\\*\\d{1,3}\\*\\* )?<sup>${ref.startVerse}</sup>`
|
|
);
|
|
const match = text.match(regExp);
|
|
if (!match) return null;
|
|
|
|
const verseLabel = match[0];
|
|
const parts = text.split(regExp);
|
|
return verseLabel + parts[1];
|
|
}
|
|
|
|
/** Extracts the text in the chapter from the start to the end verse. */
|
|
private getTextToEndVerse(
|
|
text: string,
|
|
ref: PassageReference
|
|
): string | null {
|
|
if (ref.endVerse === -1) return text;
|
|
const regex = new RegExp(
|
|
`(?:^(?:> |- )*)?<sup>${ref.endVerse + 1}</sup>`,
|
|
"m"
|
|
);
|
|
return text.split(regex, 1)[0].trim();
|
|
}
|
|
|
|
private cleanText(
|
|
text: string,
|
|
chapterNumber: number,
|
|
multipleChapters: boolean
|
|
): string {
|
|
text = this.removeChapterNumbers(text);
|
|
text = this.removeHeadings(text);
|
|
text = this.removeFootnoteRefs(text);
|
|
text = this.removeBOF(text);
|
|
text = this.removeEOF(text);
|
|
|
|
const chapterMd = multipleChapters ? `**${chapterNumber}**` : "";
|
|
if (text.startsWith("> ")) {
|
|
const quoteMd = text.match(/^(?:> )+/)![0];
|
|
return text.replace(quoteMd, `${quoteMd}${chapterMd} `);
|
|
}
|
|
|
|
if (text.startsWith("- ")) {
|
|
const listMd = text.match(/^(?:- )+/)![0];
|
|
return text.replace(listMd, `${listMd}${chapterMd} `);
|
|
}
|
|
|
|
return (text = `${chapterMd} ${text}`);
|
|
}
|
|
|
|
/** Removes chapter numbers from the given text. */
|
|
private removeChapterNumbers(text: string): string {
|
|
return text.replace(/\*\*\d{1,3}\*\* /g, "");
|
|
}
|
|
|
|
/** Removes headings from the given text. */
|
|
private removeHeadings(text: string): string {
|
|
return text.replace(/^#.*[\n\r\f]*/gm, "");
|
|
}
|
|
|
|
/** Removes footnote refs from the given text. */
|
|
private removeFootnoteRefs(text: string): string {
|
|
return text.replace(/ \[\^\w{1,9}\]/g, "");
|
|
}
|
|
|
|
/** Removes the beginning-of-file content from the given text. */
|
|
private removeBOF(text: string): string {
|
|
if (!text.startsWith("---")) return text;
|
|
// split at YAML front matter
|
|
const split = text.split(/^---$/m);
|
|
return split[2].trim();
|
|
}
|
|
|
|
/** Removes the end-of-file content from the given text. */
|
|
private removeEOF(text: string): string {
|
|
// split at chapter divider
|
|
let split = text.split(/^---$/m);
|
|
// split at footnotes
|
|
split = split[0].split(/^\[\^\d+\]:/m, 1);
|
|
return split[0].trim();
|
|
}
|
|
|
|
/** Generates an excerpt for the suggestion. */
|
|
private generateExcerpt(text: string): string {
|
|
text = text.split(/<\/sup>/, 2)[1];
|
|
text = text.replace(/(?:<sup>\d+<\/sup>|> |- )/g, "");
|
|
text = text.replace(
|
|
/<span style='font-variant: small-caps;'>Lord<\/span>/g,
|
|
"Lord"
|
|
);
|
|
text = text.replace(/\n/g, " ");
|
|
text = text.replace(/ {2,}/g, " ");
|
|
return text.slice(0, 45) + "...";
|
|
}
|
|
|
|
/** Formats the final text for suggestion. */
|
|
private formatTexts(
|
|
texts: string[],
|
|
passageRef: PassageReference,
|
|
context: EditorSuggestContext
|
|
): string {
|
|
let formatted = "";
|
|
switch (passageRef.format) {
|
|
case PassageFormat.Manuscript:
|
|
formatted = texts.join(" ").trim();
|
|
formatted = formatted.replace(/\n+/g, " ");
|
|
formatted = formatted.replace(/\*\*\d{1,3}\*\*/g, "");
|
|
formatted = formatted.replace(/<sup>\d{1,3}<\/sup> /g, "");
|
|
formatted = formatted.replace(/(?:^[>-] | [>-] )/g, " ");
|
|
formatted = formatted.trim() + "\n\n";
|
|
break;
|
|
case PassageFormat.Paragraph:
|
|
formatted = texts.join("\n\n").trim();
|
|
formatted += "\n\n";
|
|
break;
|
|
case PassageFormat.Quote:
|
|
formatted = "> ";
|
|
formatted += texts.join("\n\n").trim();
|
|
formatted = formatted.replace(/\n/gm, "\n> ");
|
|
formatted += "\n\n";
|
|
break;
|
|
case PassageFormat.Callout: {
|
|
const passageReference = passageRef.stringify();
|
|
const passageLink = this.generatePassageLink(passageRef, context);
|
|
formatted = `> [!quote] [${passageReference}](${passageLink})\n`;
|
|
formatted += texts.join("\n\n").trim();
|
|
formatted = formatted.replace(/\n/gm, "\n> ");
|
|
formatted += "\n\n";
|
|
break;
|
|
}
|
|
}
|
|
|
|
return formatted;
|
|
}
|
|
|
|
/** Generates a link to the passage within the vault. */
|
|
private generatePassageLink(
|
|
ref: PassageReference,
|
|
context: EditorSuggestContext
|
|
): string {
|
|
let link = "";
|
|
let folder: TFolder | null = context.file.parent;
|
|
while (folder?.parent) {
|
|
link += "../";
|
|
folder = folder.parent;
|
|
}
|
|
|
|
const { version, book, startChapter } = ref;
|
|
link += `${this.settings.biblesPath}/${version}/` +
|
|
`${book.name}/${book.name} ${startChapter}.md`;
|
|
return link.replace(/ /g, "%20");
|
|
}
|
|
}
|
|
|
|
interface PassageSuggestion {
|
|
excerpt: string;
|
|
text: string;
|
|
}
|