Extract lines from current note into new templated note [workflow]

[tom-rm-meyer-ISST]

Hey together,

When reading papers I often like to extract definitions. That's my rough workflow:

1. Read paper and transfer notes to Obsidian (e.g. Citavi export and some manual rewriting)
2. Create definitions following a specific template
3. Extract definition to a separate note following conventions (that way I can e.g. create a glossary using dataview (idea source)) <- purpose of this template

Usage of the template itself

1. select lines to extract -> trigger templater and select template
2. search for folder to create the note within
3. type title
4. template extracts and an embedded link remains

I reused this template to get into the topic and got the following results:

Preparation

1. Create folder structure similar to the following:

vault
- templates # folder for your markdown templates and everything to trigger
  - Extract Definition - Select Folder, File
  - ... other combinations as wanted
- scripts # folder for reusable .js folders
  - extract_lines.js

2. Update your Templater settings accordingly (control + comma > Community Plugins > Templater)

• template folder location: templates
• script files folder location: scripts

3. Copy the json script:

/*
Copyright (c) 2021 GitMurf
Copyright (c) 2024 Tom Meyer (tom-rm-meyer-ISST)

See the NOTICE file(s) distributed with this work for additional
information regarding copyright ownership.

This program and the accompanying materials are made available under the
terms of the Apache License, Version 2.0 which is available at
https://www.apache.org/licenses/LICENSE-2.0.

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
License for the specific language governing permissions and limitations
under the License.

SPDX-License-Identifier: Apache-2.0
*/

/**
 * extracts selected lines to a new file based on prompts for title 
 * 
 * @param {*} tp templater object used for prompting
 * @param {*} templateName to use to create the template, default "Definition Note"
 * @param {*} promptDefaultForNoteName default in prompt for title to use (align to template), default "Definition - X by @"
 * @param {*} replacementString to be replaced by selection, default "REPLACE_ME"
 * 
 * @returns embeeded link (![[basename]]) to the created file (tR)
 */
async function extract_lines(tp, templateName = "Definition Note", promptDefaultForNoteName = "Definition - X by @", replacementString="REPLACE_ME"){

    let tR = null;

    //Reuses code from following gists:
    //- https://gist.github.com/GitMurf/fc4132acd805b9c1413ab84c6bd11576 ( v1.6.2 )

    //After moving the line, open the file it was moved to
    const bOpenFile = true;

    //https://github.com/SilentVoid13/Templater/discussions/698
    const folders = app.vault.getAllLoadedFiles().filter(i => i instanceof tp.obsidian.TFolder).map(folder => folder.path);
    const folderPath = await tp.system.suggester(folders, folders, false, "Select Folder");
    const title = await tp.system.prompt("Title", promptDefaultForNoteName);
    new Notice("title: " + title, 5000);  
    new Notice("folderPath: " + folderPath, 5000);  

    const moveToFile = await tp.file.create_new(tp.file.find_tfile(templateName), title, false, app.vault.getAbstractFileByPath(folderPath));
    new Notice(`Created templated file for extraction: ${folderPath}/${title}`, 5000);

    if(!title  || !folderPath){
        new Notice("Aborted as either title or folderPath has not been set.", 5000);
        return
    }

    let cmEditorAct = app.workspace.activeLeaf.view.editor;
    let selectedText = cmEditorAct.getSelection();
    if(selectedText == '') {
        const curLine = cmEditorAct.getCursor().line;
        let lineContent = cmEditorAct.getLine(curLine);
        let lineLength = lineContent.length;
        cmEditorAct.setSelection({ line: curLine, ch: 0 }, { line: curLine, ch: lineLength });
        selectedText = cmEditorAct.getSelection();
    }
    const curContent = await app.vault.read(moveToFile);
    let newContents;
    let selectLine;

    // remove selected content in file and embed link to new file (no blockref)
    selectedText = '\n' + selectedText + '\n';

    const arrayEachLine = curContent.split('\n');
    selectLine = arrayEachLine.find(line => line.includes(replacementString)) || null;
    
    // pick line where to insert, if placeholder has not been found
    if(selectLine === null) {
        let arrayStrings = ['--End of File--', '--Beginning of File--'];
        let arrayValues = ['last_', 'first_'];
        arrayEachLine.forEach(eachItem => {
            if(eachItem != '') {
                arrayStrings.push(eachItem.slice(0,250));
                arrayValues.push(eachItem);
            }
        });
        selectLine = await tp.system.suggester(arrayStrings, arrayValues, false);
        if(selectLine == 'last_' || selectLine == 'first_') {
            if(selectLine == 'first_'){
                firstOrLastLine = 'first';
                newContents = selectedText + '\n' + curContent;
            } else {
                firstOrLastLine = 'last';
                newContents = curContent + '\n' + selectedText;
            }
        } else {
            if(curContent.contains('\n' + selectLine + '\n')) {
                newContents = curContent.replace('\n' + selectLine + '\n', '\n' + selectLine + '\n' + selectedText + '\n');
            } else if(curContent.startsWith(selectLine + '\n')) {
                newContents = curContent.replace(selectLine + '\n', selectLine + '\n' + selectedText + '\n');
            } else {
                firstOrLastLine = 'last';
                newContents = curContent + '\n' + selectedText;
            }
        }
    // replace the placeholder, if found
    } else {
        if(curContent.contains(selectLine)) {
            newContents = curContent.replace(selectLine, selectedText);
        } else {
            newContents = curContent + '\n' + selectedText;
        }
    }

    // write replaced string to file
    if(selectLine) {
        await app.vault.modify(moveToFile, newContents);
        if(bOpenFile) {
            await app.workspace.openLinkText(moveToFile.basename, moveToFile.path, true);
        }
        //cmEditorAct.replaceSelection(`![[${moveToFile.basename}]]`);
        // set tR variable to link to the new file
        tR = `![[${moveToFile.basename}]]`;
    }
    new Notice(`Extracted selected content to: ${folderPath}/${title}`, 5000);
    return tR;
}

module.exports = extract_lines;

4. Create the templates using parameters only (e.g. "Extract Definition - Select Folder, File")

<%* 
tR = await tp.user.extract_lines(tp, "Definition Note", "Definition - X by @", "REPLACE_ME");
%>

Notes on usage

You can overwrite the defaults as wanted by yourself or just overwrite them in the function call. What's neat for me: You can just adapt your common notes with different properties so that you can directly extract things to that particular note (for example to extract definitions from paper, extract thoughts etc.)

I for example have the following definition template I use as a basis ("Definition Note") in which the line %% REPLACE_ME %% will be replaced by the (multi- or single line) selection of your current note.

---
template-version: "2"
tags: 
publish: true
aliases: 
created: <%tp.date.now()%>
updated: 
type:
  - definition
status: open
---

# [[<%tp.file.title%>]]

---

%% REPLACE_ME %%

---

- Tags: 
	- 
- Reference:
	- 
- Related:
	-