tifa.js

class tifa {
    // !!! ALL METHODS WITH 'render' PREFIX ARE CALLED FROM OBSIDIAN              !!!
    // !!! RENAMING A 'render' METHOD WILL AFFECT ALL PAGES CALLING THE METHOD    !!!
    // !!! CHANGING A 'render' VARIABLES WILL AFFECT ALL PAGES CALLING THE METHOD !!!
    // * GLOBAL
    createCallout(type, message, content) {
        try {
            // TODO: accomodate ordered and unordered lists
            if (!type) {
                throw new Error('createCallout() called without type');
            }
            let calloutString = `> [!${type}]`;
            if (message) {
                calloutString += ` ${message}`;
            }
            if (content) {
                if (typeof content === 'string') {
                    calloutString += `\n${content}`;
                }
                else {
                    const joinedContent = content.join('\n > - ');
                    calloutString += `\n > - ${joinedContent}`;
                }
            }
            return calloutString;
        }
        catch (error) {
            return this.handleError(error, 'createCallout()');
        }
    }
    async getJSON(page, dv) {
        // TODO: Add better error handling
        // TODO: I need to know when the function fails
        // TODO: I need to know when there is no JSON
        // TODO: I need to know when the JSON is formatted incorrectly
        try {
            let content = await dv.io.load(page.file.path);
            content = content.trim();
            content = content.slice(3, -3);
            const json = JSON.parse(content);
            return json;
        }
        catch (error) {
            return false;
        }
    }
    getWordCount(content) {
        const count = content.split(' ').length;
        return count;
    }
    async addImplicitProps(note, dv) {
        const newNote = note;
        newNote.content = await dv.io.load(newNote.file.path);
        newNote.wordCount = this.getWordCount(newNote.content);
        return newNote;
    }
    handleError(error, location) {
        return `> [!bug] Problem at ${location}\n${error}`;
    }
    // * CALLOUTS
    async renderCallouts(dv, callouts) {
        try {
            if (callouts) {
                // TODO: Handle specified callouts
                dv.span(callouts);
            }
            else {
                const note = await this.addImplicitProps(dv.current(), dv);
                const readTime = await this.getReadTime(note, dv);
                if (readTime) {
                    dv.span(readTime);
                }
                await this.getNoteCallouts(note, dv);
            }
        }
        catch (error) {
            dv.span(this.handleError(error, 'renderCallouts()'));
        }
    }
    async getNoteCallouts(note, dv) {
        try {
            if (!note.type) {
                dv.span(this.createCallout('missing', 'Missing Note Type'));
                return;
            }
            const schema = await this.getJSON(dv.page(note.type + '@callouts'), dv);
            if (!schema) {
                dv.span(this.createCallout('missing', `Missing [[Callout Schema]] | [[${note.type}@callouts |Add One]]`));
                return;
            }
            let content = [];
            let done = false;
            for (let key in schema) {
                if (key === 'file') {
                    // for things like file property on a note
                    schema[key].forEach(rule => {
                        const passed = this.compareRule(note[key], rule);
                        if (!passed) {
                            rule.result.type ? dv.paragraph(this.createCallout(rule.result.type, rule.result.message, rule.result.content)) : content.push(rule.result.content);
                            if (rule.result.done) {
                                done = true;
                                return;
                            }
                        }
                    });
                }
                else {
                    schema[key].forEach(rule => {
                        const passed = this.compareRule(note, rule);
                        if (!passed) {
                            rule.result.type ? dv.paragraph(this.createCallout(rule.result.type, rule.result.message, rule.result.content)) : content.push(rule.result.content);
                            if (rule.result.done) {
                                done = true;
                                return;
                            }
                        }
                    });
                }
                if (done) {
                    return;
                }
            }
            if (done) {
                return;
            }
            if (content.length !== 0) {
                dv.paragraph(this.createCallout('warning', 'Needs Work', content));
            }
        }
        catch (error) {
            dv.span(`> [!bug] Problem with getNoteCallouts()\n${error}`);
        }
    }
    compareRule(note, rule) {
        try {
            // TODO: Handle more types than numbers
            const property = rule.property;
            const condition = rule.condition;
            if (!note[property]) {
                throw new Error(`${property} property does not exist`);
            }
            if (condition[1] === ' ') {
                let operator = condition[0];
                let value = condition.slice(-(condition.length - 2));
                if (operator === '<') {
                    return note[property] > value;
                }
                else if (operator === '>') {
                    return note[property] < value;
                }
                else if (operator === '<=') {
                    return note[property] >= value;
                }
                else if (operator === '>=') {
                    return note[property] <= value;
                }
                else if (operator === '!') {
                    return note[property] == value;
                }
                else if (operator === '=') {
                    return note[property] !== value;
                }
            }
            if (typeof condition === 'string') {
                return note[property] === condition;
            }
        }
        catch (error) {
            return `> [!bug] Problem with compareRule()\n${error}`;
        }
    }
    // * TASKS
    // TODO: handle queries and display of tasks
    async renderTasks(dv, option) {
        const tasks = dv.pages('"Journal"').file.tasks;
        const headingLevel = 3;
        // Add task due today
        const dueToday = tasks.filter(task => task.due && task.due.day === dv.parse(dv.current().file.name).day && task.due.month === dv.parse(dv.current().file.name).month && task.due.year === dv.parse(dv.current().file.name).year);
        this.createTaskList(dv, dueToday, 'Due Today', headingLevel);
        // Past due highlighted in red
        const pastDue = tasks.filter(task => task.due && task.due < dv.parse(dv.current().file.name) && !task.completed);
        this.createTaskList(dv, pastDue, 'Past Due', headingLevel);
        // No due date warning
        const noDueDate = tasks.filter(task => !task.due && !task.completed);
        this.createTaskList(dv, noDueDate, 'NO DUE DATE', headingLevel);
        // If all tasks complete, add backlog
        if (dueToday.length === 2 && pastDue.length === 3) {
            const futureTasks = tasks.filter(task => task.due && task.due > dv.parse(dv.current().file.name) && !task.completed);
            dv.span('```ad-note\n' + '' + '\n```');
        }
    }
    createTaskList(dv, tasks, heading, headingLevel) {
        if (tasks.length > 0) {
            dv.header(headingLevel, heading);
            dv.taskList(tasks, false);
        }
    }
    // * BIBLIOGRAPHY
    // TODO: handle creating bibliography for topic based on references to book notes
    renderBibliography(dv) {
        try {
            const references = this.formatReferences(this.getBookReferences(dv.current(), dv), dv);
            const bibliography = `## Bibliography\n${references.join('\n')}`;
            dv.paragraph(bibliography);
        }
        catch (error) {
            dv.span(this.handleError(error, 'renderBibliography()'));
        }
    }
    getBookReferences(noteData, dv) {
        const outlinks = noteData.file.outlinks;
        let bookReferences = [];
        outlinks.forEach(link => {
            if (dv.page(link).type === '📖') {
                bookReferences.push(link);
            }
        });
        return bookReferences;
    }
    formatReferences(references, dv) {
        const formattedReferences = [];
        references.forEach(reference => {
            const info = dv.page(reference);
            if (info.format === 'Book') {
                formattedReferences.push(`${info.author}. *${info.title}*. ${info.publishLocation}: ${info.publisher}, ${info.publishDate}. [[${info.file.name} | ⬈]]`);
            }
            if (info.format === 'Journal Article') {
                formattedReferences.push(`${info.author}. "*${info.title}*." ${info.publisher} ${info.issue} (${info.publishDate}): ${info.pages} [[${info.file.name} | ⬈]]`);
            }
        });
        return formattedReferences;
    }
    // * ESTIMATED READ TIME
    async getReadTime(note, dv) {
        try {
            const content = await dv.io.load(note.file.path);
            const wordCount = this.getWordCount(content);
            const readTime = Math.round(wordCount / 200);
            let hourText = '';
            let minText = '';
            let hours = '';
            let mins = '';
            // set mins and hours
            if (readTime > 60) {
                hours = Math.floor(readTime / 60);
                mins = readTime % 60;
            }
            else {
                mins = readTime;
            }
            // set hour text
            if (hours) {
                hours === 1 ? hourText = 'hr' : hourText = 'hrs';
            }
            // set min text
            mins === 1 ? minText = 'min' : minText = 'mins';
            return `>[!info] READ TIME: ${hours} ${hourText} ${mins} ${minText}`;
        }
        catch (error) {
            dv.span(this.handleError(error, 'getReadTime()'));
        }
    }
}