Help! - Multi-line Input Prompt

[lucasbcgeo]

Hi,
What should I write in the user script called by the macro to enable the multi-line prompt?

Or how i add multiple non existing values with a macro?

[chhoumann]

For scripts you should reference the API documentation: https://quickadd.obsidian.guide/docs/QuickAddAPI#wideinputprompt-header-string-placeholder-string-value-promisestring

In your case:

await quickAddApi.wideInputPrompt("Heading", "placeholder", "Default value")

[lucasbcgeo]

I would like to fill several values for just one placeholder, is it possible? In fact the situation is: I'm using the script to create a note from a template and then fill in its properties/yaml. The issue is that certain property fields have their values in list format.

Obs: some of these values are being created when typing at the prompt and others already exist in the vault.

dc.title: "<% tp.file.title %>"
aliases:
  - "{{VALUE:aliases}}"
dc.definition:
  - "{{VALUE:definition}}"

Expected result

dc.title: papé
aliases:
  - "bla bla bla"
  - "ble ble blo"
  - "bli bli bli"
dc.definition:
  - "[[lalalalal lalal laala, lalala]]"
  - "[[le le lo]]"

My result:

dc.title: papé
aliases:"
  - bla bla bla"
  - "ble ble blo"
  - "bli bli bli"
dc.definition:"
  -  [[lalalalal lalal laala, lalala]]"
  - "[[le le lo]]"

Not multiple values =(

What should the script and template structure be like?

---

My template properties:

---
dc.title: "<% tp.file.title %>"
aliases:
  - "{{VALUE:aliases}}"
dc.definition:
  - "{{VALUE:definition}}"
dc.definition.Abstract:
  - "{{VALUE:definition.Abstract}}"
lei.Seca:
  - "{{VALUE:lei_seca}}"
doutrina:
  - "{{VALUE:doutrina}}"
jurisprudência:
  - "{{VALUE:jurisprudencia}}"
dc.source:
  - "{{VALUE:fontes}}"
dc.relation.ispartOf:
  - "{{VALUE:termosPais}}"
relation.siblings:
  - "{{VALUE:termosIrmãos}}"
dc.relation.hasPart:
  - "{{VALUE:termosFilhos}}"
dc.relation.references:
  - "{{VALUE:conceitosRelacionados}}"
dc.type: "glossário"
tags:
  - "🔤/⚖️"
dc.date.created: "<% tp.file.creation_date('YYYY-MM-DD HH:mm') %>"
dc.date.modified: ""
dc.identifier.uri: "obsidian://open?vault=MeuVault&file=<%* tR += encodeURIComponent(tp.file.path()) %>"
cssclasses:
  - "wide-table"
  - "wide-page"
  ---

My script:

module.exports = async ({ app, quickAddApi }) => {
    // Coleta o nome do arquivo no início
    const fileName = await quickAddApi.inputPrompt('Nome do Arquivo');

    // Inicializando as listas e valores simples
    
    let aliases = [];
    let termosPais = [];
    let termosIrmãos = [];
    let termosFilhos = [];
    let fontes = [];
    let conceitosRelacionados = [];
    let definicao = "";
    let contexto = "";
    let exemplo = "";
    let definition = "";
    let definitionAbstract = "";
    let leiSeca = "";
    let doutrina = "";
    let jurisprudencia = "";


    // Coleta de definição, contexto, exemplo
    definition = await quickAddApi.inputPrompt("Definição curta poucas palavras");
    definitionAbstract = await quickAddApi.inputPrompt("Resumo da Definição Máximo 2,3 linhas");
    leiSeca = await quickAddApi.inputPrompt("Lei Seca");
    doutrina = await quickAddApi.inputPrompt("Doutrina");
    jurisprudencia = await quickAddApi.inputPrompt("Jurisprudência");
    definicao = await quickAddApi.inputPrompt("Definição com + detalhes");
    contexto = await quickAddApi.inputPrompt("Contexto");
    exemplo = await quickAddApi.inputPrompt("Exemplo");








     // Coleta de termos pais
     while (true) {
        const termoPai = await quickAddApi.inputPrompt("Adicione um Termo Pai (ou deixe vazio para terminar):");
        if (termoPai.trim() === "") break;
        termosPais.push(termoPai);
    }

    // Coleta de termos irmãos
    while (true) {
        const termoIrmao = await quickAddApi.inputPrompt("Adicione um Termo Irmão (ou deixe vazio para terminar):");
        if (termoIrmao.trim() === "") break;
        termosIrmãos.push(termoIrmao);
    }

    // Coleta de termos filhos
    while (true) {
        const termoFilho = await quickAddApi.inputPrompt("Adicione um Termo Filho (ou deixe vazio para terminar):");
        if (termoFilho.trim() === "") break;
        termosFilhos.push(termoFilho);
    }

    // Coleta de fontes
    while (true) {
        const fonte = await quickAddApi.inputPrompt("Adicione uma Fonte (ou deixe vazio para terminar):");
        if (fonte.trim() === "") break;
        fontes.push(fonte);
    }

    while (true) {
        const aliase = await quickAddApi.inputPrompt("Adicione um aliase (ou deixe vazio para terminar):");
        if (aliase.trim() === "") break;
        aliases.push(aliase);
    }

    while (true) {
        const conceitoRelacionado = await quickAddApi.inputPrompt("Adicione um Conceito Relacionado ou sem parentesco claro definido (ou deixe vazio para terminar):");
        if (conceitoRelacionado.trim() === "") break;
        conceitosRelacionados.push(conceitoRelacionado);
    }
 
    


    // Função para formatar listas para uma única linha com vírgulas
    function formatList(terms, includeBrackets = false) {
        if (terms.length === 0) return "";
    
        // Primeiro termo tratado separadamente
        let firstTermFormatted = includeBrackets ? `"[[${terms[0]}]]"` : `${terms[0]}`;
    
        // Processa os termos restantes com base na sua posição
        let formattedTerms = terms.slice(1).map((term, index, arr) => {
            // Último termo na lista de termos restantes (efetivamente o último termo da lista original)
            if (index === arr.length - 1) {
                // Último termo, formatado com ou sem colchetes, mas sem aspas duplas
                return `  - ${includeBrackets ? `"[[${term}]]` : `${term}`}`;
            } else {
                // Termos intermediários, precedidos por " -" e formatados com ou sem colchetes
                return `  - ${includeBrackets ? `"[[${term}]]"` : `${term}`}`;
            }
        });
    
        // Combina o primeiro termo com os termos restantes, adicionando quebra de linha apenas após o primeiro termo
        return firstTermFormatted + (formattedTerms.length > 0 ? '\n' + formattedTerms.join('\n') : '');
    }
    
 


    // Formatação dos valores coletados para inserção no template
    const formattedTermosPais = formatList(termosPais, true);
    const formattedTermosIrmãos = formatList(termosIrmãos, true);
    const formattedTermosFilhos = formatList(termosFilhos, true);
    const formattedConceitosRelacionados = formatList(conceitosRelacionados, true);
    const formattedFontes = formatList(fontes);
    const formattedAliases = formatList(aliases);

    // Carregamento do template
    const templatePath = 'Dispensa/Templates/GlossárioT/Glossário-Programação.md';
    let templateContent = await app.vault.adapter.read(templatePath);

    // Substituição dos placeholders no template pelos valores formatados
    templateContent = templateContent.replace("{{VALUE:aliases}}", formattedAliases)
                                      .replace("{{VALUE:definition}}", definition)
                                      .replace("{{VALUE:definition.Abstract}}", definitionAbstract)
                                      .replace("{{VALUE:lei_seca}}", leiSeca)
                                      .replace("{{VALUE:doutrina}}", doutrina)
                                      .replace("{{VALUE:jurisprudencia}}", jurisprudencia)
                                      .replace("{{VALUE:termosPais}}", formattedTermosPais)                                                                    
                                      .replace("{{VALUE:termosIrmãos}}", formattedTermosIrmãos)
                                      .replace("{{VALUE:termosFilhos}}", formattedTermosFilhos)
                                      .replace("{{VALUE:fontes}}", formattedFontes)
                                      .replace("{{VALUE:conceitosRelacionados}}", formattedConceitosRelacionados)
                                      .replace("{{VALUE:contexto}}", contexto)
                                      .replace("{{VALUE:exemplo}}", exemplo)
                                      .replace("{{VALUE:definicao}}", definicao)


    // Criação da nova nota e redirecionamento opcional para ela
    const newFilePath = `Dispensa/data base/Glossário/${fileName}.md`;
    await app.vault.create(newFilePath, templateContent);

    if (await quickAddApi.yesNoPrompt('Deseja ser redirecionado para a nova nota?')) {
        const newNote = await app.vault.getAbstractFileByPath(newFilePath);
        app.workspace.activeLeaf.openFile(newNote);
    }
};