mirror of
https://github.com/sbuffkin/hexmaker.git
synced 2026-07-22 14:30:24 +00:00
772 lines
27 KiB
TypeScript
772 lines
27 KiB
TypeScript
import { App, Notice, TFile } from "obsidian";
|
||
import { HexmakerModal } from "../HexmakerModal";
|
||
import { parseRandomTable, extractPostTableContent, parseMarkdownListItems } from "./randomTable";
|
||
import type { RandomTableEntry } from "./randomTable";
|
||
import { FileLinkSuggestModal } from "../hex-map/FileLinkSuggestModal";
|
||
import type HexmakerPlugin from "../HexmakerPlugin";
|
||
import { normalizeFolder } from "../utils";
|
||
|
||
/**
|
||
* Modal editor for a random table file.
|
||
* Shows existing entries as editable rows and allows adding new ones.
|
||
* Saves back to the file, preserving frontmatter.
|
||
*/
|
||
export class RandomTableEditorModal extends HexmakerModal {
|
||
// Held so onClose can flush a pending "add row" entry and save it
|
||
private flushAndSave: (() => Promise<void>) | null = null;
|
||
|
||
constructor(
|
||
app: App,
|
||
private plugin: HexmakerPlugin,
|
||
private file: TFile,
|
||
private onSaved?: () => void,
|
||
private initialContent?: string,
|
||
) {
|
||
super(app);
|
||
}
|
||
|
||
async onOpen(): Promise<void> {
|
||
this.titleEl.setText(`Edit: ${this.file.basename}`);
|
||
const { contentEl } = this;
|
||
contentEl.addClass("duckmage-table-editor");
|
||
|
||
const rawContent =
|
||
this.initialContent ?? (await this.app.vault.read(this.file));
|
||
const table = parseRandomTable(rawContent);
|
||
const frontmatter = this.extractFrontmatter(rawContent);
|
||
const preamble = this.extractPreamble(rawContent, frontmatter);
|
||
|
||
// Working copy so edits don't mutate until Save
|
||
const entries: RandomTableEntry[] = table.entries.map((e) => ({ ...e }));
|
||
|
||
// If linked to a folder, silently drop entries whose note no longer exists
|
||
if (table.linkedFolder) {
|
||
const lf = normalizeFolder(table.linkedFolder);
|
||
for (let i = entries.length - 1; i >= 0; i--) {
|
||
if (
|
||
!this.app.vault.getAbstractFileByPath(`${lf}/${entries[i].result}.md`)
|
||
) {
|
||
entries.splice(i, 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Track each entry's original result by object identity (survives drag-reorder)
|
||
const entryOriginalResult = new WeakMap<RandomTableEntry, string>();
|
||
entries.forEach((e) => entryOriginalResult.set(e, e.result));
|
||
|
||
// Snapshot of original results so deleted entries can be retired on save
|
||
const originalResults = new Set(entries.map((e) => e.result));
|
||
|
||
// ── Name (rename) ────────────────────────────────────────────────
|
||
const nameRow = contentEl.createDiv({
|
||
cls: "duckmage-table-editor-name-row",
|
||
});
|
||
nameRow.createEl("label", {
|
||
text: "Name",
|
||
cls: "duckmage-table-editor-name-label",
|
||
});
|
||
const nameInput = nameRow.createEl("input", {
|
||
type: "text",
|
||
cls: "duckmage-table-editor-name-input",
|
||
});
|
||
nameInput.value = this.file.basename;
|
||
|
||
const doRename = async () => {
|
||
const newName = nameInput.value.trim();
|
||
if (!newName || newName === this.file.basename) return;
|
||
const dir = this.file.path.slice(
|
||
0,
|
||
this.file.path.length - this.file.name.length,
|
||
);
|
||
const newPath = dir + newName + ".md";
|
||
try {
|
||
await this.app.fileManager.renameFile(this.file, newPath);
|
||
this.titleEl.setText(`Edit: ${this.file.basename}`);
|
||
this.onSaved?.();
|
||
} catch {
|
||
nameInput.value = this.file.basename; // revert on error
|
||
}
|
||
};
|
||
|
||
nameInput.addEventListener("blur", () => void doRename());
|
||
nameInput.addEventListener("keydown", (e: KeyboardEvent) => {
|
||
if (e.key === "Enter") {
|
||
e.preventDefault();
|
||
nameInput.blur();
|
||
}
|
||
if (e.key === "Escape") {
|
||
nameInput.value = this.file.basename;
|
||
nameInput.blur();
|
||
}
|
||
});
|
||
|
||
// ── Entries section (grows to fill available space) ───────────────
|
||
const entriesSection = contentEl.createDiv({
|
||
cls: "duckmage-table-editor-entries-section",
|
||
});
|
||
|
||
// ── Existing rows ─────────────────────────────────────────────────
|
||
const entriesHeadingRow = entriesSection.createDiv({
|
||
cls: "duckmage-table-editor-entries-heading-row",
|
||
});
|
||
entriesHeadingRow.createEl("p", {
|
||
text: "Entries",
|
||
cls: "duckmage-table-editor-heading",
|
||
});
|
||
|
||
// ── Sort buttons ──────────────────────────────────────────────────
|
||
let weightSortAsc = false;
|
||
let alphaSortAsc = false;
|
||
const stripLeadingSpecial = (s: string) =>
|
||
s.replace(/^[^a-zA-Z0-9]+/, "").toLowerCase();
|
||
|
||
const weightSortBtn = entriesHeadingRow.createEl("button", {
|
||
text: "Wt ↑",
|
||
cls: "duckmage-table-editor-add-one-btn",
|
||
attr: { title: "Sort entries by weight (low → high)" },
|
||
});
|
||
weightSortBtn.addEventListener("click", () => {
|
||
weightSortAsc = !weightSortAsc;
|
||
entries.sort((a, b) =>
|
||
weightSortAsc ? a.weight - b.weight : b.weight - a.weight,
|
||
);
|
||
weightSortBtn.setText(weightSortAsc ? "Wt ↓" : "Wt ↑");
|
||
weightSortBtn.title = weightSortAsc
|
||
? "Sort entries by weight (high → low)"
|
||
: "Sort entries by weight (low → high)";
|
||
renderRows();
|
||
});
|
||
|
||
const alphaSortBtn = entriesHeadingRow.createEl("button", {
|
||
text: "A→z",
|
||
cls: "duckmage-table-editor-add-one-btn",
|
||
attr: { title: "Sort entries alphabetically (a → z)" },
|
||
});
|
||
alphaSortBtn.addEventListener("click", () => {
|
||
alphaSortAsc = !alphaSortAsc;
|
||
entries.sort((a, b) => {
|
||
const ka = stripLeadingSpecial(a.result);
|
||
const kb = stripLeadingSpecial(b.result);
|
||
return alphaSortAsc ? ka.localeCompare(kb) : kb.localeCompare(ka);
|
||
});
|
||
alphaSortBtn.setText(alphaSortAsc ? "Z→a" : "A→z");
|
||
alphaSortBtn.title = alphaSortAsc
|
||
? "Sort entries alphabetically (z → a)"
|
||
: "Sort entries alphabetically (a → z)";
|
||
renderRows();
|
||
});
|
||
|
||
const subOneToAllBtn = entriesHeadingRow.createEl("button", {
|
||
text: "-1",
|
||
cls: "duckmage-table-editor-add-one-btn",
|
||
attr: { title: "Add 1 to every entry's weight" },
|
||
});
|
||
subOneToAllBtn.addEventListener("click", () => {
|
||
for (const e of entries) e.weight -= 1;
|
||
renderRows();
|
||
});
|
||
const addOneToAllBtn = entriesHeadingRow.createEl("button", {
|
||
text: "+1",
|
||
cls: "duckmage-table-editor-add-one-btn",
|
||
attr: { title: "Add 1 to every entry's weight" },
|
||
});
|
||
addOneToAllBtn.addEventListener("click", () => {
|
||
for (const e of entries) e.weight += 1;
|
||
renderRows();
|
||
});
|
||
|
||
const importBtn = entriesHeadingRow.createEl("button", {
|
||
text: "Import…",
|
||
cls: "duckmage-table-editor-add-one-btn",
|
||
attr: { title: "Import list items from a vault note" },
|
||
});
|
||
importBtn.addEventListener("click", () => {
|
||
new FileLinkSuggestModal(
|
||
this.app,
|
||
this.plugin,
|
||
(file: TFile) => {
|
||
void (async () => {
|
||
const content = await this.app.vault.read(file);
|
||
const items = parseMarkdownListItems(content);
|
||
if (items.length === 0) {
|
||
new Notice(`No list items found in "${file.basename}"`);
|
||
return;
|
||
}
|
||
for (const item of items) {
|
||
entries.push({ result: item, weight: 1 });
|
||
}
|
||
renderRows();
|
||
new Notice(`Imported ${items.length} item${items.length === 1 ? "" : "s"} from "${file.basename}"`);
|
||
})();
|
||
},
|
||
"",
|
||
).open();
|
||
});
|
||
|
||
const rowsEl = entriesSection.createDiv({
|
||
cls: "duckmage-table-editor-rows",
|
||
});
|
||
|
||
let dragSrcIndex = -1;
|
||
|
||
const autoResize = (el: HTMLTextAreaElement) => {
|
||
el.setCssProps({ height: "auto" });
|
||
el.setCssProps({ height: `${el.scrollHeight}px` });
|
||
};
|
||
|
||
const renderRows = () => {
|
||
rowsEl.empty();
|
||
if (entries.length === 0) {
|
||
rowsEl.createSpan({
|
||
text: "No entries yet.",
|
||
cls: "duckmage-rt-empty",
|
||
});
|
||
return;
|
||
}
|
||
for (let i = 0; i < entries.length; i++) {
|
||
const entry = entries[i];
|
||
const row = rowsEl.createDiv({ cls: "duckmage-table-editor-row" });
|
||
row.draggable = true;
|
||
|
||
const handle = row.createSpan({
|
||
cls: "duckmage-table-editor-drag-handle",
|
||
text: "⠿",
|
||
});
|
||
handle.title = "Drag to reorder";
|
||
|
||
const resultInput = row.createEl("textarea", {
|
||
cls: "duckmage-table-editor-result",
|
||
});
|
||
// Show [[path]] for link entries so the user can see and edit the link format
|
||
resultInput.value = entry.isLink ? `[[${entry.result}]]` : entry.result;
|
||
resultInput.placeholder = "Result…";
|
||
resultInput.rows = 1;
|
||
// Size to content immediately, then keep in sync as the user types
|
||
requestAnimationFrame(() => autoResize(resultInput));
|
||
resultInput.addEventListener("input", () => {
|
||
const val = resultInput.value;
|
||
const m = /^\[\[(.+?)(?:\|[^\]]+)?\]\]$/.exec(val.trim());
|
||
if (m) {
|
||
entries[i].result = m[1];
|
||
entries[i].isLink = true;
|
||
} else {
|
||
entries[i].result = val;
|
||
entries[i].isLink = undefined;
|
||
}
|
||
autoResize(resultInput);
|
||
});
|
||
|
||
const weightInput = row.createEl("input", {
|
||
type: "number",
|
||
cls: "duckmage-table-editor-weight",
|
||
});
|
||
weightInput.value = String(entry.weight);
|
||
//weightInput.min = "1";
|
||
weightInput.addEventListener("input", () => {
|
||
entries[i].weight = Math.max(1, parseInt(weightInput.value, 10) || 1);
|
||
});
|
||
// weightInput.addEventListener("keydown", (e: KeyboardEvent) => {
|
||
// if (e.key === "ArrowDown" && entries[i].weight <= 1) {
|
||
// e.preventDefault();
|
||
// for (let j = 0; j < entries.length; j++) {
|
||
// if (j !== i) entries[j].weight += 1;
|
||
// }
|
||
// renderRows();
|
||
// }
|
||
// });
|
||
|
||
const delBtn = row.createEl("button", {
|
||
text: "×",
|
||
cls: "duckmage-table-editor-del",
|
||
});
|
||
delBtn.title = "Remove row";
|
||
delBtn.addEventListener("click", () => {
|
||
entries.splice(i, 1);
|
||
renderRows();
|
||
});
|
||
|
||
row.addEventListener("dragstart", (e: DragEvent) => {
|
||
dragSrcIndex = i;
|
||
row.addClass("duckmage-table-editor-dragging");
|
||
e.dataTransfer?.setDragImage(row, 0, 0);
|
||
});
|
||
row.addEventListener("dragend", () => {
|
||
row.removeClass("duckmage-table-editor-dragging");
|
||
rowsEl
|
||
.querySelectorAll(".duckmage-table-editor-drop-target")
|
||
.forEach((el) =>
|
||
el.classList.remove("duckmage-table-editor-drop-target"),
|
||
);
|
||
});
|
||
row.addEventListener("dragover", (e: DragEvent) => {
|
||
e.preventDefault();
|
||
rowsEl
|
||
.querySelectorAll(".duckmage-table-editor-drop-target")
|
||
.forEach((el) =>
|
||
el.classList.remove("duckmage-table-editor-drop-target"),
|
||
);
|
||
row.addClass("duckmage-table-editor-drop-target");
|
||
});
|
||
row.addEventListener("dragleave", () => {
|
||
row.removeClass("duckmage-table-editor-drop-target");
|
||
});
|
||
row.addEventListener("drop", (e: DragEvent) => {
|
||
e.preventDefault();
|
||
if (dragSrcIndex === -1 || dragSrcIndex === i) return;
|
||
const [moved] = entries.splice(dragSrcIndex, 1);
|
||
entries.splice(i, 0, moved);
|
||
dragSrcIndex = -1;
|
||
renderRows();
|
||
});
|
||
}
|
||
};
|
||
renderRows();
|
||
|
||
// ── Add new row ───────────────────────────────────────────────────
|
||
entriesSection.createEl("p", {
|
||
text: "Add row",
|
||
cls: "duckmage-table-editor-heading",
|
||
});
|
||
const addRow = entriesSection.createDiv({
|
||
cls: "duckmage-table-editor-add-row",
|
||
});
|
||
|
||
const newResult = addRow.createEl("textarea", {
|
||
cls: "duckmage-table-editor-result",
|
||
});
|
||
newResult.placeholder = "New result…";
|
||
newResult.rows = 1;
|
||
|
||
const newWeight = addRow.createEl("input", {
|
||
type: "number",
|
||
cls: "duckmage-table-editor-weight",
|
||
});
|
||
newWeight.value = "1";
|
||
newWeight.min = "1";
|
||
|
||
const addBtn = addRow.createEl("button", {
|
||
text: "Add",
|
||
cls: "duckmage-table-editor-add-btn mod-cta",
|
||
});
|
||
|
||
const errorEl = entriesSection.createDiv({
|
||
cls: "duckmage-table-editor-add-error",
|
||
});
|
||
errorEl.hide();
|
||
|
||
// ── Description ───────────────────────────────────────────────────
|
||
const descRow = contentEl.createDiv({
|
||
cls: "duckmage-table-editor-desc-row",
|
||
});
|
||
descRow.createEl("label", {
|
||
text: "Description",
|
||
cls: "duckmage-table-editor-desc-label",
|
||
});
|
||
const descInput = descRow.createEl("textarea", {
|
||
cls: "duckmage-table-editor-desc-input",
|
||
});
|
||
descInput.placeholder = "Optional description shown above the table…";
|
||
descInput.value = table.description ?? "";
|
||
descInput.rows = 3;
|
||
|
||
// ── Linked folder ─────────────────────────────────────────────────
|
||
const folderRow = contentEl.createDiv({
|
||
cls: "duckmage-table-editor-folder-row",
|
||
});
|
||
folderRow.createEl("label", {
|
||
text: "Linked folder",
|
||
cls: "duckmage-table-editor-folder-label",
|
||
});
|
||
const folderDatalistId =
|
||
"duckmage-lf-folders-" + Math.random().toString(36).slice(2);
|
||
const folderDatalist = contentEl.createEl("datalist");
|
||
folderDatalist.id = folderDatalistId;
|
||
const seenFolders = new Set<string>();
|
||
// Add configured settings folders first (excluding hexFolder)
|
||
const s = this.plugin.settings;
|
||
for (const raw of [
|
||
s.townsFolder,
|
||
s.dungeonsFolder,
|
||
s.questsFolder,
|
||
s.featuresFolder,
|
||
s.factionsFolder,
|
||
s.tablesFolder,
|
||
s.workflowsFolder,
|
||
]) {
|
||
const p = normalizeFolder(raw);
|
||
if (p && !seenFolders.has(p)) {
|
||
seenFolders.add(p);
|
||
folderDatalist.createEl("option", { value: p });
|
||
}
|
||
}
|
||
// Add all vault subfolders under worldFolder or any settings folder
|
||
const folderRoots = [
|
||
s.worldFolder,
|
||
s.townsFolder,
|
||
s.dungeonsFolder,
|
||
s.questsFolder,
|
||
s.featuresFolder,
|
||
s.factionsFolder,
|
||
s.tablesFolder,
|
||
s.workflowsFolder,
|
||
]
|
||
.map(normalizeFolder)
|
||
.filter(Boolean);
|
||
for (const f of this.app.vault.getAllFolders()) {
|
||
const p = normalizeFolder(f.path);
|
||
if (!p) continue;
|
||
const underRoot = folderRoots.some(
|
||
(r) => p === r || p.startsWith(r + "/"),
|
||
);
|
||
if (!underRoot) continue;
|
||
if (!seenFolders.has(p)) {
|
||
seenFolders.add(p);
|
||
folderDatalist.createEl("option", { value: p });
|
||
}
|
||
}
|
||
const folderInput = folderRow.createEl("input", {
|
||
type: "text",
|
||
cls: "duckmage-table-editor-folder-input",
|
||
});
|
||
folderInput.setAttribute("list", folderDatalistId);
|
||
folderInput.value = table.linkedFolder ?? "";
|
||
folderInput.placeholder = "World/towns (leave blank for none)";
|
||
|
||
// ── Filter settings ───────────────────────────────────────────────
|
||
// Terrain description/encounter tables manage these flags programmatically — hide UI.
|
||
const isSystemTable = /^table-type:/m.test(frontmatter);
|
||
const filterSection = contentEl.createDiv({
|
||
cls: "duckmage-table-editor-filter-section",
|
||
});
|
||
if (isSystemTable) filterSection.hide();
|
||
|
||
const rollFilterRow = filterSection.createDiv({
|
||
cls: "duckmage-table-editor-filter-row",
|
||
});
|
||
const rollFilterCb = rollFilterRow.createEl("input", { type: "checkbox" });
|
||
rollFilterCb.checked =
|
||
this.parseFrontmatterBool(frontmatter, "roll-filter") === false;
|
||
rollFilterRow.createEl("label", { text: "Exclude from roll picker" });
|
||
|
||
const encFilterRow = filterSection.createDiv({
|
||
cls: "duckmage-table-editor-filter-row",
|
||
});
|
||
const encFilterCb = encFilterRow.createEl("input", { type: "checkbox" });
|
||
encFilterCb.checked =
|
||
this.parseFrontmatterBool(frontmatter, "encounter-filter") === false;
|
||
encFilterRow.createEl("label", { text: "Exclude from encounters table" });
|
||
|
||
const doAdd = () => {
|
||
const raw = newResult.value.trim();
|
||
if (!raw) return;
|
||
|
||
// Detect vault-relative link format: explicit [[...]] or a path containing / or \
|
||
const explicitLink = /^\[\[(.+?)(?:\|[^\]]+)?\]\]$/.exec(raw);
|
||
const linkPath = explicitLink ? explicitLink[1] : raw;
|
||
const looksLikeLink =
|
||
explicitLink !== null ||
|
||
linkPath.includes("/") ||
|
||
linkPath.includes("\\");
|
||
|
||
if (looksLikeLink) {
|
||
// Normalize backslashes and strip .md extension if present
|
||
const normalizedPath = linkPath
|
||
.replace(/\\/g, "/")
|
||
.replace(/\.md$/i, "");
|
||
// Try exact vault-relative path, then case-insensitive scan, then Obsidian's link resolver
|
||
const found =
|
||
this.app.vault.getAbstractFileByPath(normalizedPath + ".md") ??
|
||
this.app.vault
|
||
.getMarkdownFiles()
|
||
.find(
|
||
(f) =>
|
||
f.path.slice(0, -3).trim().toLowerCase() ===
|
||
normalizedPath.toLowerCase(),
|
||
) ??
|
||
this.app.metadataCache.getFirstLinkpathDest(
|
||
normalizedPath,
|
||
this.file.path,
|
||
);
|
||
if (!(found instanceof TFile)) {
|
||
errorEl.setText(`No note found: "${normalizedPath}"`);
|
||
errorEl.show();
|
||
return;
|
||
}
|
||
errorEl.hide();
|
||
// Store the vault-relative path without extension (canonical link form)
|
||
const resolvedPath = found.path.replace(/\.md$/i, "");
|
||
const weight = Math.max(1, parseInt(newWeight.value, 10) || 1);
|
||
entries.push({ result: resolvedPath, weight, isLink: true });
|
||
} else {
|
||
errorEl.hide();
|
||
const weight = Math.max(1, parseInt(newWeight.value, 10) || 1);
|
||
entries.push({ result: raw, weight });
|
||
}
|
||
|
||
newResult.value = "";
|
||
newWeight.value = "1";
|
||
renderRows();
|
||
newResult.focus();
|
||
};
|
||
// Expose so onClose always saves all changes (flushes pending "add row" text first)
|
||
this.flushAndSave = async () => {
|
||
doAdd(); // flush pending "add row" text if any (no-op if empty)
|
||
const suffix = extractPostTableContent(rawContent) || undefined;
|
||
let updatedFm = this.setFrontmatterBool(
|
||
frontmatter,
|
||
"roll-filter",
|
||
rollFilterCb.checked ? false : undefined,
|
||
);
|
||
updatedFm = this.setFrontmatterBool(
|
||
updatedFm,
|
||
"encounter-filter",
|
||
encFilterCb.checked ? false : undefined,
|
||
);
|
||
const linkedFolder = normalizeFolder(folderInput.value.trim());
|
||
updatedFm = this.setFrontmatterString(
|
||
updatedFm,
|
||
"linkedFolder",
|
||
linkedFolder ? `"[[${linkedFolder}]]"` : undefined,
|
||
);
|
||
if (linkedFolder) {
|
||
await this.renameUpdatedEntries(
|
||
entries,
|
||
entryOriginalResult,
|
||
linkedFolder,
|
||
);
|
||
await this.retireDeletedEntries(originalResults, entries, linkedFolder);
|
||
await this.syncLinkedFolder(entries, linkedFolder);
|
||
}
|
||
// Rebuild preamble: preserve or insert roller block, replace user description
|
||
const rollerLinkMatch =
|
||
preamble.match(/```duckmage-roller[\s\S]*?```/) ??
|
||
preamble.match(/\[.*?\]\(obsidian:\/\/duckmage-roll[^)]*\)/);
|
||
// Always include a roller — upgrade old URI links to the code block form
|
||
const rollerLink =
|
||
rollerLinkMatch?.index !== undefined &&
|
||
/```duckmage-roller/.test(rollerLinkMatch[0])
|
||
? rollerLinkMatch[0]
|
||
: "```duckmage-roller\n```";
|
||
const newDescription = descInput.value.trim();
|
||
const newPreamble = [rollerLink, newDescription]
|
||
.filter(Boolean)
|
||
.join("\n\n");
|
||
const newContent = this.buildContent(
|
||
updatedFm,
|
||
newPreamble,
|
||
entries,
|
||
linkedFolder || undefined,
|
||
suffix,
|
||
);
|
||
try {
|
||
await this.app.vault.process(this.file, () => newContent);
|
||
this.onSaved?.();
|
||
} catch {
|
||
/* best-effort */
|
||
}
|
||
};
|
||
|
||
addBtn.addEventListener("click", doAdd);
|
||
// Enter submits; Shift+Enter inserts a newline
|
||
newResult.addEventListener("keydown", (e: KeyboardEvent) => {
|
||
if (e.key === "Enter" && !e.shiftKey) {
|
||
e.preventDefault();
|
||
doAdd();
|
||
}
|
||
});
|
||
|
||
// ── Footer: Close (auto-saves on close) ───────────────────────────
|
||
const footer = contentEl.createDiv({ cls: "duckmage-table-editor-footer" });
|
||
|
||
footer
|
||
.createEl("button", { text: "Close", cls: "mod-cta" })
|
||
.addEventListener("click", () => this.close());
|
||
|
||
this.makeDraggable();
|
||
}
|
||
|
||
/** Sync entries ↔ notes in linkedFolder. Mutates entries in-place. */
|
||
private async syncLinkedFolder(
|
||
entries: RandomTableEntry[],
|
||
folderPath: string,
|
||
): Promise<void> {
|
||
// Ensure folder exists
|
||
if (!this.app.vault.getAbstractFileByPath(folderPath)) {
|
||
try {
|
||
await this.app.vault.createFolder(folderPath);
|
||
} catch {
|
||
/* may already exist */
|
||
}
|
||
}
|
||
|
||
// Notes currently in the folder
|
||
const existing = this.app.vault
|
||
.getMarkdownFiles()
|
||
.filter(
|
||
(f) => f.parent?.path === folderPath && !f.basename.startsWith("_"),
|
||
);
|
||
|
||
// For each entry: create note if missing
|
||
for (const entry of entries) {
|
||
const notePath = `${folderPath}/${entry.result}.md`;
|
||
const noteFile = this.app.vault.getAbstractFileByPath(notePath);
|
||
if (!noteFile) {
|
||
try {
|
||
await this.app.vault.create(notePath, `# ${entry.result}\n`);
|
||
} catch {
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
|
||
// For each note without a matching entry: add entry
|
||
const entryNames = new Set(entries.map((e) => e.result));
|
||
for (const noteFile of existing) {
|
||
if (!entryNames.has(noteFile.basename)) {
|
||
entries.push({ result: noteFile.basename, weight: 1 });
|
||
}
|
||
}
|
||
}
|
||
|
||
/** Rename notes whose entry result text was changed, instead of creating a new note. */
|
||
private async renameUpdatedEntries(
|
||
entries: RandomTableEntry[],
|
||
originalResults: WeakMap<RandomTableEntry, string>,
|
||
folderPath: string,
|
||
): Promise<void> {
|
||
for (const entry of entries) {
|
||
const orig = originalResults.get(entry);
|
||
if (!orig || orig === entry.result) continue;
|
||
const oldPath = `${folderPath}/${orig}.md`;
|
||
const newPath = `${folderPath}/${entry.result}.md`;
|
||
const noteFile = this.app.vault.getAbstractFileByPath(oldPath);
|
||
if (!(noteFile instanceof TFile)) continue;
|
||
if (this.app.vault.getAbstractFileByPath(newPath)) continue; // target already exists
|
||
try {
|
||
await this.app.fileManager.renameFile(noteFile, newPath);
|
||
} catch {
|
||
/* best-effort */
|
||
}
|
||
}
|
||
}
|
||
|
||
/** Prepend "_" to notes whose entries were deleted, so they are excluded from future syncs. */
|
||
private async retireDeletedEntries(
|
||
originalResults: Set<string>,
|
||
currentEntries: RandomTableEntry[],
|
||
folderPath: string,
|
||
): Promise<void> {
|
||
const currentNames = new Set(currentEntries.map((e) => e.result));
|
||
for (const result of originalResults) {
|
||
if (currentNames.has(result)) continue;
|
||
const notePath = `${folderPath}/${result}.md`;
|
||
const noteFile = this.app.vault.getAbstractFileByPath(notePath);
|
||
if (!(noteFile instanceof TFile)) continue;
|
||
const newPath = `${folderPath}/_${result}.md`;
|
||
try {
|
||
await this.app.fileManager.renameFile(noteFile, newPath);
|
||
} catch {
|
||
/* already renamed or missing */
|
||
}
|
||
}
|
||
}
|
||
|
||
onClose(): void {
|
||
// If the user typed something in "Add row" and closed without clicking Add,
|
||
// flush it and save so the entry isn't lost.
|
||
void this.flushAndSave?.();
|
||
this.flushAndSave = null;
|
||
this.contentEl.empty();
|
||
}
|
||
|
||
/** Read a `key: true|false` line from a frontmatter block string. Returns undefined if absent. */
|
||
private parseFrontmatterBool(
|
||
frontmatter: string,
|
||
key: string,
|
||
): boolean | undefined {
|
||
const m = frontmatter.match(
|
||
new RegExp(`^${key}:\\s*(true|false)\\s*$`, "m"),
|
||
);
|
||
if (!m) return undefined;
|
||
return m[1] === "true";
|
||
}
|
||
|
||
/**
|
||
* Set, remove, or update a boolean key in a frontmatter block string.
|
||
* If value is undefined the key line is removed.
|
||
* If the key doesn't exist and value is not undefined, it is inserted before the closing `---`.
|
||
*/
|
||
private setFrontmatterBool(
|
||
frontmatter: string,
|
||
key: string,
|
||
value: boolean | undefined,
|
||
): string {
|
||
const lineRegex = new RegExp(`^${key}:.*$`, "m");
|
||
const hasKey = lineRegex.test(frontmatter);
|
||
if (value === undefined) {
|
||
if (!hasKey) return frontmatter;
|
||
// Remove the line (and any trailing newline)
|
||
return frontmatter.replace(new RegExp(`^${key}:.*\\n?`, "m"), "");
|
||
}
|
||
const line = `${key}: ${value}`;
|
||
if (hasKey) {
|
||
return frontmatter.replace(lineRegex, line);
|
||
}
|
||
// Insert before closing ---
|
||
return frontmatter.replace(/\n---$/, `\n${line}\n---`);
|
||
}
|
||
|
||
/** Set, remove, or update a string key in a frontmatter block string. */
|
||
private setFrontmatterString(
|
||
frontmatter: string,
|
||
key: string,
|
||
value: string | undefined,
|
||
): string {
|
||
const lineRegex = new RegExp(`^${key}:.*$`, "m");
|
||
const hasKey = lineRegex.test(frontmatter);
|
||
if (!value) {
|
||
if (!hasKey) return frontmatter;
|
||
return frontmatter.replace(new RegExp(`^${key}:.*\\n?`, "m"), "");
|
||
}
|
||
const line = `${key}: ${value}`;
|
||
if (hasKey) return frontmatter.replace(lineRegex, line);
|
||
return frontmatter.replace(/\n---$/, `\n${line}\n---`);
|
||
}
|
||
|
||
private extractFrontmatter(content: string): string {
|
||
const match = content.match(/^---\n[\s\S]*?\n---/);
|
||
return match ? match[0] : "";
|
||
}
|
||
|
||
private extractPreamble(content: string, frontmatter: string): string {
|
||
const afterFm = frontmatter ? content.slice(frontmatter.length) : content;
|
||
// Find first markdown table row (line starting with |)
|
||
const tableMatch = afterFm.match(/^[ \t]*\|/m);
|
||
if (!tableMatch || tableMatch.index === undefined) return "";
|
||
return afterFm.slice(0, tableMatch.index).trim();
|
||
}
|
||
|
||
private buildContent(
|
||
frontmatter: string,
|
||
preamble: string,
|
||
entries: RandomTableEntry[],
|
||
linkedFolder?: string,
|
||
suffix?: string,
|
||
): string {
|
||
const rows = entries
|
||
.map((e) => {
|
||
const cell = linkedFolder || e.isLink ? `[[${e.result}]]` : e.result;
|
||
return `| ${cell} | ${e.weight} |`;
|
||
})
|
||
.join("\n");
|
||
const tableBlock = `| Result | Weight |\n|--------|--------|\n${rows}`;
|
||
const parts: string[] = [];
|
||
if (frontmatter) parts.push(frontmatter);
|
||
if (preamble) parts.push(preamble);
|
||
parts.push(tableBlock);
|
||
let result = parts.join("\n\n") + "\n";
|
||
if (suffix) result += "\n" + suffix;
|
||
return result;
|
||
}
|
||
}
|