[Item] Merge Blockquotes by Sections

[RichardFaucheron]

Description

Function

This template is designed to summarize multiple notes into a single Markdown file. It organizes the content by grouping blockquotes under specific section headings, with links to both the corresponding PDFs and the notes themselves.

The main goal is to allow quick comparison of your notes for each section by using blockquotes as summaries. If similar blockquotes are found across different notes, they are merged into one.

The default headings that the template scans for are : ["Model", "Forecast", "Uncertainty", "Latent", "Loss", "Train", "Data", "Results", "Experiments", "Review"]).

How to use

1. Ensure consistency in your note-taking by using headings and blockquotes to summarize each section
2. Generate a note using this template, by selecting the items for which you have written notes

Personalization

• Change Headings : Modify the list of headings to suit your preferences by updating the myHeadingList variable:
  const myHeadingList = ["Model", "Forecast", "Uncertainty", "Latent", "Loss","Train", "Data", "Results", "Experiments", "Review"];

• Change Heading Levels : Adjust the level of headings the script scans by modifying the regex pattern:
  const headingRegex = /^##\s+(.*)$/gm;

• Customize Section Summaries : Instead of using blockquotes, you can change the string key that fetches your summaries. Update the blockquote regex as follows:

• const blockquoteRegex = /^>\s+(.+)$/gm;

Screenshots

Test on Zotero version

7.0.11

Test on Better Notes version

2.1.9

Template Type

Item

Template Share Code

# This template is specifically for importing/sharing, using better
# notes 'import from clipboard': copy the content and
# goto Zotero menu bar, click Edit->New Template from Clipboard.
# Do not copy-paste this to better notes template editor directly.
name: "[item] Merge Blockquotes by Sections"
content: |-
  // @author Richard Faucheron
  // @beforeloop-begin
	${{
	sharedObj.notesDict = {};
	sharedObj.quotesDict = {};
	sharedObj.updateNotes = (title, note) => {
		if (!(title in sharedObj.notesDict)) {
			sharedObj.notesDict[title] = [];
		}
		sharedObj.notesDict[title].push(note);
	};
	sharedObj.updateQuotes = (heading, quote) => {
		if (!(heading in sharedObj.quotesDict)) {
			sharedObj.quotesDict[heading] = [];
		}
		sharedObj.quotesDict[heading].push(quote);
	};
	return "";
	}}$

	${{
	async function getPDFLink(item) {
		const att = await item.getBestAttachment();
		if (!att || !att.isPDFAttachment()) {
		return "";
		}
		key = att.key;
		if (att.libraryID === 1) {
		return `zotero://open/library/items/${key}`;
		} else {
		groupID = Zotero.Libraries.get(att.libraryID).id;
		return `zotero://open/groups/${groupID}/items/${key}`;
		}
	}
	sharedObj.getPDFLink = getPDFLink;
	return "";
	}}$
	// @beforeloop-end
	// @default-begin
	// @use-markdown
	${{
		// Store notes and their titles
		const notesAndTitles = [];

		// Get (author, year) with PDF link of current item
		const creators = topItem.getCreators();
		const year = topItem.getField("year");
		let content = "";
		if (creators.length === 0) {
			content = "no author";
		} else if (creators.length === 1) {
			content = `${creators[0].lastName}, ${year}`;
		} else {
			content = `${creators[0].lastName} et al., ${year}`;
		}
		content += `, ${topItem.getField("title")}`
		// The getPDFLink function is from above
		const link = await sharedObj.getPDFLink(topItem);
		//let title = `<a href="${link}">${content}</a>`;
		let title = `[${content}](${link})`;

		// Get notes
		const notes = Zotero.Items.get(topItem.getNotes());
		notesAndTitles.splice(0, 0, ...notes);

		// Update
		notesAndTitles.forEach((note) => {
			sharedObj.updateNotes(title, note)
		})
		return "";
	}}$
	// @default-end
	// @afterloop-begin
	// @use-markdown
	${{
		// Function to retrieve the targeted level 2 heading and its corresponding quotes from md file
		const processMarkdownOneHeading = (markdownContent, targetHeading, itemLink) => {
			const headingRegex = /^##\s+(.*)$/gm; // Match level 2 headings
			const blockquoteRegex = /^>\s+(.+)$/gm; // Match blockquotes
			let result = '';
			let currentHeading = null;
			let isTargetHeadingFound = false;
			let itemID = itemLink

			const lines = markdownContent.split('\n');

			for (const line of lines) {
				let match;

				// Check for level 2 headings
				headingRegex.lastIndex = 0;
				if ((match = headingRegex.exec(line))) {
					currentHeading = match[1].trim(); // Get heading text
					if (currentHeading === targetHeading) {
						isTargetHeadingFound = true; // Start collecting quotes
					} else if (isTargetHeadingFound) {
						break; // Stop collecting when a new heading is found
					}
				}

				// Collect blockquotes only if we're under the target heading
				blockquoteRegex.lastIndex = 0;
				if (isTargetHeadingFound && (match = blockquoteRegex.exec(line))) {
					// Retrieve the quote from the blockquote
					let quote = match[1].trim();


					// Check if the quote already exists in sharedObj.quotesDict under the heading
					if (sharedObj.quotesDict[targetHeading]) {
						// Check if the exact quote already exists in the list
						const existingQuoteIndex = sharedObj.quotesDict[targetHeading].findIndex(
						(existingQuote) => existingQuote.startsWith(quote)
						);

						if (existingQuoteIndex !== -1) {
							// Quote already exists, append the itemLink to it
							sharedObj.quotesDict[targetHeading][existingQuoteIndex] += `, ${itemLink}`;
						} else {
							// Quote doesn't exist, add it as a new entry
							sharedObj.quotesDict[targetHeading].push(`${quote} --- [ ${itemLink}`);
						}
					} else {
						// If no quotes exist for the heading, create a new list
						sharedObj.quotesDict[targetHeading] = [`${quote} --- [ ${itemLink}`];
					}
				}
			}
			// Also list headings without quotes
			if (!(targetHeading in sharedObj.quotesDict)) {
				sharedObj.quotesDict[targetHeading] = [];
			}
			return result.trim(); // Return collected quotes
		};
		
		let res = "";
		let ref = "***\n# References\n";
		let itemID = 0;
		const myHeadingList = ["Model", "Forecast", "Uncertainty", "Latent", "Loss",
							"Train", "Data", "Results", "Experiments", "Review"];

		for (const title in sharedObj.notesDict) {
			for (const note of sharedObj.notesDict[title]) {
				
				itemID += 1;
				ref += `[${itemID}] ${title} | [*Note*](${Zotero.BetterNotes.api.convert.note2link(note)})`;
				ref += "\n\n"
				const itemLink = `[${itemID}](${Zotero.BetterNotes.api.convert.note2link(note)})`;
				
				const md = await Zotero.BetterNotes.api.convert.note2md(note);
				for (const heading of myHeadingList) {
					const quote = processMarkdownOneHeading(md, heading, itemLink);
				}
			}
		}
		// Fill headings and notes
		for (let heading in sharedObj.quotesDict) {
			res += `## ${heading}\n`;
			for (let quote of sharedObj.quotesDict[heading]) {
				const lines = quote.split("\n");
				for (let l of lines) {
					if (l) {
						res +=`- ${l} ]\n`;  // matching '[' is in processMarkdownOneHeading
					}
				}
			}
		}	
		return res += ref;
	}}$
	// @afterloop-end

Anything else

No response