/*
THIS IS A GENERATED/BUNDLED FILE BY ROLLUP
if you want to view the source visit the plugins github repository

'Shell commands' plugin for Obsidian.
Copyright (C) 2021 - 2023 Jarkko Linnanvirta

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.

Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
*/

'use strict';

var obsidian = require('obsidian');
var child_process = require('child_process');
var os = require('os');
var path = require('path');
var electron = require('electron');
var fs = require('fs');

function _interopNamespace(e) {
    if (e && e.__esModule) return e;
    var n = Object.create(null);
    if (e) {
        Object.keys(e).forEach(function (k) {
            if (k !== 'default') {
                var d = Object.getOwnPropertyDescriptor(e, k);
                Object.defineProperty(n, k, d.get ? d : {
                    enumerable: true,
                    get: function () { return e[k]; }
                });
            }
        });
    }
    n["default"] = e;
    return Object.freeze(n);
}

var path__namespace = /*#__PURE__*/_interopNamespace(path);
var fs__namespace = /*#__PURE__*/_interopNamespace(fs);

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Modal extends obsidian.Modal {
    constructor(plugin) {
        super(plugin.app);
        this.plugin = plugin;
        this._isOpen = false;
    }
    onOpen() {
        this._isOpen = true;
        // Make the modal scrollable if it has more content than what fits in the screen.
        this.modalEl.addClass("SC-modal", "SC-scrollable");
        // Approve the modal by pressing the enter key (if enabled).
        if (this.plugin.settings.approve_modals_by_pressing_enter_key) {
            this.scope.register([], "enter", (event) => {
                // Check that no textarea is focused and no autocomplete menu is open.
                if (0 === document.querySelectorAll("textarea:focus").length &&
                    0 === document.querySelectorAll("div.SC-autocomplete").length) {
                    // No textareas with focus and no open autocomplete menus were found.
                    this.approve();
                    event.preventDefault();
                    event.stopPropagation();
                }
            });
        }
    }
    isOpen() {
        return this._isOpen;
    }
    setTitle(title) {
        this.titleEl.innerText = title;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class ConfirmationModal extends SC_Modal {
    constructor(plugin, title, question, yes_button_text) {
        super(plugin);
        this.question = question;
        this.yes_button_text = yes_button_text;
        this.approved = false;
        this.setTitle(title);
        this.promise = new Promise((resolve) => {
            this.resolve_promise = resolve;
        });
    }
    onOpen() {
        super.onOpen();
        // Display the question
        this.modalEl.createEl("p", { text: this.question });
        // Display the yes button
        new obsidian.Setting(this.modalEl)
            .addButton(button => button
            .setButtonText(this.yes_button_text)
            .onClick(() => this.approve()));
    }
    approve() {
        // Got a confirmation from a user
        this.resolve_promise(true);
        this.approved = true;
        this.close();
    }
    onClose() {
        super.onClose();
        if (!this.approved) { // TODO: Find out if there is a way to not use this kind of flag property. Can the status be checked from the promise itself?
            this.resolve_promise(false);
        }
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * If true, logging stuff to console.log() will be enabled.
 * Might also enable some testing {{variables}} in the future, perhaps.
 */
let DEBUG_ON = false;
function setDEBUG_ON(value) {
    DEBUG_ON = value;
}
/**
 * Calls console.log(), but only if debugging is enabled.
 * @param message
 */
function debugLog(message) {
    if (DEBUG_ON) {
        console.log(message);
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class IDGenerator {
    constructor(reserved_ids = [], min_length = 10, characters = "abcdefghijklmnopqrstuvwxyz0123456789") {
        this.reserved_ids = reserved_ids;
        this.min_length = min_length;
        this.characters = characters;
    }
    addReservedID(id) {
        debugLog(IDGenerator.name + ": Adding id " + id + " to the list of reserved ids.");
        this.reserved_ids.push(id);
    }
    generateID() {
        let generated_id = "";
        while (generated_id.length < this.min_length || this.isIDReserved(generated_id)) {
            generated_id += this.generateCharacter();
        }
        this.reserved_ids.push(generated_id);
        debugLog(IDGenerator.name + ": Generated id " + generated_id);
        return generated_id;
    }
    getReservedIDs() {
        return this.reserved_ids;
    }
    generateCharacter() {
        return this.characters.charAt(Math.floor(Math.random() * this.characters.length));
    }
    isIDReserved(id) {
        return this.reserved_ids.contains(id);
    }
}
const id_generator = new IDGenerator();
function getIDGenerator() {
    return id_generator;
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function getVaultAbsolutePath(app) {
    // Original code was copied 2021-08-22 from https://github.com/phibr0/obsidian-open-with/blob/84f0e25ba8e8355ff83b22f4050adde4cc6763ea/main.ts#L66-L67
    // But the code has been rewritten 2021-08-27 as per https://github.com/obsidianmd/obsidian-releases/pull/433#issuecomment-906087095
    const adapter = app.vault.adapter;
    if (adapter instanceof obsidian.FileSystemAdapter) {
        return adapter.getBasePath();
    }
    throw new Error("Could not retrieve vault path. No DataAdapter was found from app.vault.adapter.");
}
function getPluginAbsolutePath(plugin) {
    return normalizePath2(path__namespace.join(getVaultAbsolutePath(plugin.app), plugin.app.vault.configDir, "plugins", plugin.getPluginId()));
}
/**
 * For some reason there is no Platform.isWindows .
 */
function isWindows() {
    return process.platform === "win32";
}
/**
 * This is just a wrapper around platform() in order to cast the type to PlatformId.
 * TODO: Consider renaming this to getPlatformId().
 */
function getOperatingSystem() {
    // @ts-ignore In theory, platform() can return an OS name not included in OperatingSystemName. But as Obsidian
    // currently does not support anything else than Windows, Mac and Linux (except mobile platforms, but they are
    // ruled out by the manifest of this plugin), it should be safe to assume that the current OS is one of those
    // three.
    return os.platform();
}
function getView(app) {
    const view = app.workspace.getActiveViewOfType(obsidian.MarkdownView);
    if (!view) {
        debugLog("getView(): Could not get a view. Will return null.");
        return null;
    }
    return view;
}
function getEditor(app) {
    const view = getView(app);
    if (null === view) {
        // Could not get a view.
        return null;
    }
    // Ensure that view.editor exists! It exists at least if this is a MarkDownView.
    if ("editor" in view) {
        // Good, it exists.
        // @ts-ignore We already know that view.editor exists.
        return view.editor;
    }
    // Did not find an editor.
    debugLog("getEditor(): 'view' does not have a property named 'editor'. Will return null.");
    return null;
}
// eslint-disable-next-line @typescript-eslint/ban-types
function cloneObject(object) {
    return Object.assign({}, object);
}
/**
 * Merges two or more objects together. If they have same property names, former objects' properties get overwritten by later objects' properties.
 *
 * @param objects
 */
// eslint-disable-next-line @typescript-eslint/ban-types
function combineObjects(...objects) {
    return Object.assign({}, ...objects);
}
function mergeSets(set1, set2) {
    return new Set([...set1, ...set2]);
}
/**
 * Returns a new Set cloned from 'from_set', with all items presented in 'remove' removed from it.
 *
 * @param from_set
 * @param remove Can be either a Set of removable items, or a single item.
 */
function removeFromSet(from_set, remove) {
    const reduced_set = new Set(from_set);
    if (remove instanceof Set) {
        for (const removable of remove) {
            reduced_set.delete(removable);
        }
    }
    else {
        reduced_set.delete(remove);
    }
    return reduced_set;
}
/**
 * Same as normalizePath(), but fixes these glitches:
 * - Leading forward slashes / backward slashes should not be removed.
 * - \ should not be converted to / if platform is Windows. In other words, / should be converted to \ if platform is Windows.
 *
 * TODO: I've opened a discussion about this on Obsidian's forums. If anything new comes up in the discussion, make changes accordingly. https://forum.obsidian.md/t/normalizepath-removes-a-leading/24713
 */
function normalizePath2(path) {
    // 1. Preparations
    path = path.trim();
    const leading_slashes_regexp = /^[/\\]*/gu; // Get as many / or \ slashes as there are in the very beginning of path. Can also be "" (an empty string).
    const leading_slashes_array = leading_slashes_regexp.exec(path); // An array with only one item.
    if (null === leading_slashes_array) {
        // It should always match. This exception should never happen, but have it just in case.
        throw new Error("normalizePath2(): leading_slashes_regexp did not match.");
    }
    let leading_slashes = leading_slashes_array[0];
    // 2. Run the original normalizePath()
    path = obsidian.normalizePath(path);
    // 3. Fixes
    // Check that correct slashes are used.
    if (isWindows()) {
        // The platform is Windows.
        // Convert / to \
        path = path.replace(/\//gu, "\\"); // Need to use a regexp instead of a normal "/" -> "\\" replace because the normal replace would only replace first occurrence of /.
        leading_slashes = leading_slashes.replace(/\//gu, "\\"); // Same here.
    }
    // Now ensure that path still contains leading slashes (if there were any before calling normalizePath()).
    // Check that the path should have a similar set of leading slashes at the beginning. It can be at least "/" (on linux/Mac), or "\\" (on Windows when it's a network path), in theory even "///" or "\\\\\" whatever.
    // normalizePath() seems to remove leading slashes (and they are needed to be re-added), but it's needed to check first, otherwise the path would have double leading slashes if normalizePath() gets fixed in the future.
    if (leading_slashes.length && path.slice(0, leading_slashes.length) !== leading_slashes) {
        // The path does not contain the required set of leading slashes, so add them.
        path = leading_slashes + path;
    }
    // 4. Done
    return path;
}
function extractFileName(file_path, with_extension = true) {
    if (with_extension) {
        return path__namespace.parse(file_path).base;
    }
    else {
        return path__namespace.parse(file_path).name;
    }
}
function extractFileParentPath(file_path) {
    return path__namespace.parse(file_path).dir;
}
// eslint-disable-next-line @typescript-eslint/ban-types
function joinObjectProperties(object, glue) {
    let result = "";
    for (const property_name in object) {
        if (result.length) {
            result += glue;
        }
        // @ts-ignore
        result += object[property_name];
    }
    return result;
}
/**
 * Removes all duplicates from an array.
 *
 * Idea is copied 2021-10-06 from https://stackoverflow.com/a/33121880/2754026
 */
function uniqueArray(array) {
    return [...new Set(array)];
}
/**
 * Opens a web browser in the specified URL.
 * @param url
 */
function gotoURL(url) {
    electron.shell.openExternal(url); // This returns a promise, but it can be ignored as there's nothing to do after opening the browser.
}
function generateObsidianCommandName(plugin, shell_command, alias) {
    const prefix = plugin.settings.obsidian_command_palette_prefix;
    if (alias) {
        // If an alias is set for the command, Obsidian's command palette should display the alias text instead of the actual command.
        return prefix + alias;
    }
    return prefix + shell_command;
}
function isInteger(value, allow_minus) {
    if (allow_minus) {
        return !!value.match(/^-?\d+$/u);
    }
    else {
        return !!value.match(/^\d+$/u);
    }
}
/**
 * Translates 1-indexed caret line and column to a 0-indexed EditorPosition object. Also translates a possibly negative line
 * to a positive line from the end of the file, and a possibly negative column to a positive column from the end of the line.
 * @param editor
 * @param caret_line
 * @param caret_column
 */
function prepareEditorPosition(editor, caret_line, caret_column) {
    // Determine line
    if (caret_line < 0) {
        // Negative line means to calculate it from the end of the file.
        caret_line = Math.max(0, editor.lastLine() + caret_line + 1);
    }
    else {
        // Positive line needs just a small adjustment.
        // Editor line is zero-indexed, line numbers are 1-indexed.
        caret_line -= 1;
    }
    // Determine column
    if (caret_column < 0) {
        // Negative column means to calculate it from the end of the line.
        caret_column = Math.max(0, editor.getLine(caret_line).length + caret_column + 1);
    }
    else {
        // Positive column needs just a small adjustment.
        // Editor column is zero-indexed, column numbers are 1-indexed.
        caret_column -= 1;
    }
    return {
        line: caret_line,
        ch: caret_column,
    };
}
function getSelectionFromTextarea(textarea_element, return_null_if_empty) {
    const selected_text = textarea_element.value.substring(textarea_element.selectionStart, textarea_element.selectionEnd);
    return "" === selected_text && return_null_if_empty ? null : selected_text;
}
/**
 * Creates an HTMLElement (with freely decidable tag) and adds the given content into it as normal text. No HTML formatting
 * is supported, i.e. possible HTML special characters are shown as-is. Newline characters are converted to <br> elements.
 *
 * @param tag
 * @param content
 * @param parent_element
 */
function createMultilineTextElement(tag, content, parent_element) {
    const content_element = parent_element.createEl(tag);
    // Insert content line-by-line
    const content_lines = content.split(/\r\n|\r|\n/g); // Don't use ( ) with | because .split() would then include the newline characters in the resulting array.
    content_lines.forEach((content_line, content_line_index) => {
        // Insert the line.
        content_element.insertAdjacentText("beforeend", content_line);
        // Insert a linebreak <br> if needed.
        if (content_line_index < content_lines.length - 1) {
            content_element.insertAdjacentHTML("beforeend", "<br>");
        }
    });
    return content_element;
}
function randomInteger(min, max) {
    const range = max - min + 1;
    return min + Math.floor(Math.random() * range);
}
/**
 * Does the following prefixings:
 *   \ will become \\
 *   [ will become \[
 *   ] will become \]
 *   ( will become \(
 *   ) will become \)
 *
 * @param content
 */
function escapeMarkdownLinkCharacters(content) {
    // TODO: \[ can be replaced with [ as eslint suggests and ten remove the ignore line below. I'm not doing it now because it would be outside of the scope of this commit/issue #70.
    // eslint-disable-next-line no-useless-escape
    return content.replace(/[\\()\[\]]/gu, "\\$&");
}
function copyToClipboard(text) {
    return electron.clipboard.writeText(text);
}
async function getFileContentWithoutYAML(app, file) {
    return new Promise((resolve) => {
        // The logic is borrowed 2022-09-01 from https://forum.obsidian.md/t/how-to-get-current-file-content-without-yaml-frontmatter/26197/2
        // Thank you, endorama! <3
        const file_content = app.vault.read(file);
        file_content.then((file_content) => {
            const frontmatter_cache = app.metadataCache.getFileCache(file)?.frontmatter;
            if (frontmatter_cache) {
                // A YAML frontmatter is present in the file.
                const frontmatter_end_line_number = frontmatter_cache.position.end.line + 1; // + 1: Take the last --- line into account, too.
                const file_content_without_frontmatter = file_content.split("\n").slice(frontmatter_end_line_number).join("\n");
                return resolve(file_content_without_frontmatter);
            }
            else {
                // No YAML frontmatter is present in the file.
                // Return the whole file content, because there's nothing to remove.
                return resolve(file_content);
            }
        });
    });
}
async function getFileYAML(app, file, withDashes) {
    return new Promise((resolve) => {
        // The logic is borrowed 2022-09-01 from https://forum.obsidian.md/t/how-to-get-current-file-content-without-yaml-frontmatter/26197/2
        // Thank you, endorama! <3
        const fileContent = app.vault.read(file);
        fileContent.then((file_content) => {
            const frontmatterCache = app.metadataCache.getFileCache(file)?.frontmatter;
            if (frontmatterCache) {
                // A YAML frontmatter is present in the file.
                const frontmatterEndLineNumber = frontmatterCache.position.end.line + 1; // + 1: Take the last --- line into account, too.
                let firstLine;
                let lastLine;
                if (withDashes) {
                    // Take full YAML content, including --- lines at the top and bottom.
                    firstLine = 0;
                    lastLine = frontmatterEndLineNumber;
                }
                else {
                    // Exclude --- lines.
                    firstLine = 1;
                    lastLine = frontmatterEndLineNumber - 1;
                }
                const frontmatterContent = file_content.split("\n").slice(firstLine, lastLine).join("\n");
                return resolve(frontmatterContent);
            }
            else {
                // No YAML frontmatter is present in the file.
                return resolve(null);
            }
        });
    });
}

/**
 * Escapes a string that will be used as a pattern in a regular expression.
 *
 * Note that this does not escape minus: - . It's probably ok as long as you won't wrap the result of this function in square brackets [ ] . For more information, read a comment by coolaj86 on Nov 29, 2019 at 2:44 in this Stack Overflow answer: https://stackoverflow.com/a/6969486/2754026
 *
 * Copied 2022-03-10 from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
 * Modifications:
 *  - Added TypeScript data type hints for the parameter and return value.
 *  - Added 'export' keyword.
 *  - Added this JSDoc.
 *  - No other changes.
 *
 * @param string
 * @return string
 */
function escapeRegExp(string) {
    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
const DocumentationMainLink = "https://publish.obsidian.md/shellcommands";
const DocumentationBuiltInVariablesBaseLink = "https://publish.obsidian.md/shellcommands/Variables/"; // When used, a variable's name will be appended to the end. Keep the trailing slash!
const DocumentationBuiltInVariablesIndexLink = "https://publish.obsidian.md/shellcommands/Variables/Variables+-+general+principles#All+variables";
const DocumentationCustomVariablesLink = "https://publish.obsidian.md/shellcommands/Variables/Custom+variables";
const DocumentationAutocompleteLink = "https://publish.obsidian.md/shellcommands/Variables/Autocomplete/Autocomplete";
const DocumentationEventsFolderLink = "https://publish.obsidian.md/shellcommands/Events/";
const DocumentationPATHAugmentationsLink = "https://publish.obsidian.md/shellcommands/Environments/Additions+to+the+PATH+environment+variable";
const DocumentationOutputWrappersLink = "https://publish.obsidian.md/shellcommands/Output+handling/Output+wrappers";
const DocumentationOutputHandlingModeLink = "https://publish.obsidian.md/shellcommands/Output+handling/Realtime+output+handling";
const DocumentationStdinContentLink = "https://publish.obsidian.md/shellcommands/Variables/Pass+variables+to+stdin";
const GitHubLink = "https://github.com/Taitava/obsidian-shellcommands";
const ChangelogLink = "https://github.com/Taitava/obsidian-shellcommands/blob/main/CHANGELOG.md";
const LicenseLink = "https://github.com/Taitava/obsidian-shellcommands/blob/main/LICENSE";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * Variables that can be used to inject values to shell commands using {{variable:argument}} syntax.
 */
class Variable {
    constructor(plugin) {
        this.plugin = plugin;
        /**
         * If this is false, the variable can be assigned a default value that can be used in situations where the variable is unavailable.
         * TODO: Set to false, as most Variables are not always available. Then remove all 'always_available = false' lines from subclasses, and add 'always_available = true' to those subclasses that need it.
         * @protected
         */
        this.always_available = true;
        this.app = plugin.app;
    }
    getValue(t_shell_command = null, sc_event = null, variableArguments = {}, 
    /**
     * Will parse variables in a default value (only used if this variable is not available this time). The callback
     * is only used, if t_shell_command is given. Set to null, if no variable parsing is needed for default values.
     * */
    default_value_parser = null) {
        return new Promise((resolve) => {
            // Cast arguments (if any) to their correct data types
            const castedArguments = this.castArguments(variableArguments);
            // Generate a value, or catch an exception if one occurs.
            this.generateValue(castedArguments, sc_event).then((value) => {
                // Value generation succeeded.
                return resolve({
                    value: value,
                    error_messages: [],
                    succeeded: true,
                });
            }).catch((error) => {
                // Caught a VariableError or an Error.
                if (error instanceof VariableError) {
                    // The variable is not available in this situation.
                    debugLog(this.constructor.name + ".getValue(): Caught a VariableError and will determine how to handle it: " + error.message);
                    // Check what should be done.
                    const default_value_configuration = t_shell_command?.getDefaultValueConfigurationForVariable(this); // The method can return undefined, and t_shell_command can be null.
                    const default_value_type = default_value_configuration ? default_value_configuration.type : "show-errors";
                    const debug_message_base = "Variable " + this.getFullName() + " is not available. ";
                    switch (default_value_type) {
                        case "show-errors":
                            // Generate error messages by calling generateValue().
                            debugLog(debug_message_base + "Will prevent shell command execution and show visible error messages.");
                            return resolve({
                                value: null,
                                error_messages: [error.message],
                                succeeded: false,
                            });
                        case "cancel-silently":
                            // Prevent execution, but do not show any errors
                            debugLog(debug_message_base + "Will prevent shell command execution silently without visible error messages.");
                            return resolve({
                                value: null,
                                error_messages: [],
                                succeeded: false,
                            });
                        case "value":
                            // Return a default value.
                            if (!default_value_configuration) {
                                // This should not happen, because default_value_type is never "value" when default_value_configuration is undefined or null.
                                // This check is just for TypeScript compiler to understand that default_value_configuration is defined when it's accessed below.
                                throw new Error("Default value configuration is undefined.");
                            }
                            debugLog(debug_message_base + "Will use a default value: " + default_value_configuration.value);
                            if (default_value_parser) {
                                // Parse possible variables in the default value.
                                default_value_parser(default_value_configuration.value).then((default_value_parsing_result) => {
                                    return resolve({
                                        value: default_value_parsing_result.succeeded
                                            ? default_value_parsing_result.parsed_content
                                            : default_value_parsing_result.original_content,
                                        error_messages: default_value_parsing_result.error_messages,
                                        succeeded: default_value_parsing_result.succeeded,
                                    });
                                });
                            }
                            else {
                                // No variable parsing is wanted.
                                return resolve({
                                    value: default_value_configuration.value,
                                    error_messages: [],
                                    succeeded: true,
                                });
                            }
                            break;
                        default:
                            throw new Error("Unrecognised default value type: " + default_value_type);
                    }
                }
                else {
                    // A program logic error has happened.
                    debugLog(this.constructor.name + ".getValue(): Caught an unrecognised error of class: " + error.constructor.name + ". Will rethrow it.");
                    throw error;
                }
            });
        });
    }
    getParameters() {
        const child_class = this.constructor;
        return child_class.parameters;
    }
    getParameterSeparator() {
        const child_class = this.constructor;
        return child_class.parameter_separator;
    }
    getPattern() {
        const error_prefix = this.variable_name + ".getPattern(): ";
        let pattern = '\\{\\{!?' + escapeRegExp(this.variable_name);
        for (const parameter_name in this.getParameters()) {
            const parameter = this.getParameters()[parameter_name];
            let parameter_type_pattern = this.getParameterSeparator(); // Here this.parameter_separator (= : ) is included in the parameter value just so that it's not needed to do nested parenthesis to accomplish possible optionality: (:())?. parseShellCommandVariables() will remove the leading : .
            // Check should we use parameter.options or parameter.type.
            if (undefined === parameter.options &&
                undefined === parameter.type) {
                // Neither is defined :(
                throw Error(error_prefix + "Parameter '" + parameter_name + "' should define either 'type' or 'options', neither is defined!");
            }
            else if (undefined !== parameter.options &&
                undefined !== parameter.type) {
                // Both are defined :(
                throw Error(error_prefix + "Parameter '" + parameter_name + "' should define either 'type' or 'options', not both!");
            }
            else if (undefined !== parameter.options) {
                // Use parameter.options
                parameter_type_pattern += parameter.options.join("|" + this.getParameterSeparator()); // E.g. "absolute|:relative" for {{file_path:mode}} variable's 'mode' parameter.
            }
            else {
                // Use parameter.type
                switch (parameter.type) {
                    case "string":
                        parameter_type_pattern += ".*?";
                        break;
                    case "integer":
                        parameter_type_pattern += "\\d+";
                        break;
                    default:
                        throw Error(error_prefix + "Parameter '" + parameter_name + "' has an unrecognised type: " + parameter.type);
                }
            }
            // Add the subpattern to 'pattern'.
            pattern += "(" + parameter_type_pattern + ")";
            if (!parameter.required) {
                // Make the parameter optional.
                pattern += "?";
            }
        }
        pattern += '\\}\\}';
        return pattern;
    }
    getParameterNames() {
        return Object.getOwnPropertyNames(this.getParameters());
    }
    /**
     * @param variableArguments String typed arguments. Arguments that should be typed otherly, will be cast to other types. Then all arguments are returned.
     */
    castArguments(variableArguments) {
        const castedArguments = {};
        for (const parameterName of Object.getOwnPropertyNames(variableArguments)) {
            const parameter_type = this.getParameters()[parameterName].type ?? "string"; // If the variable uses "options" instead of "type", then the type is always "string".
            const argument = variableArguments[parameterName];
            switch (parameter_type) {
                case "string":
                    castedArguments[parameterName] = argument;
                    break;
                case "integer":
                    castedArguments[parameterName] = parseInt(argument);
                    break;
            }
        }
        return castedArguments;
    }
    /**
     * Creates a VariableError and passes it to a rejector function, which will pass the VariableError to Variable.getValue().
     * Then it will be handled there according to user preferences.
     *
     * @param message
     * @param rejector
     * @protected
     */
    reject(message, rejector) {
        rejector(this.newVariableError(message));
    }
    /**
     * Similar to Variable.reject(), but uses a traditional throw. Can be used in async methods. For methods that create
     * Promises manually, Variable.reject() should be used, because errors thrown in manually created Promises are not caught
     * by Variable.getValue()'s Promise.catch() callback.
     *
     * @param message
     * @protected
     */
    throw(message) {
        throw this.newVariableError(message);
    }
    newVariableError(message) {
        const prefix = this.getFullName() + ": ";
        return new VariableError(prefix + message);
    }
    getAutocompleteItems() {
        // Check if the variable has at least one _mandatory_ parameter.
        let parameter_indicator = "";
        const parameter_names = Object.getOwnPropertyNames(this.getParameters())
            .filter(parameter_name => this.getParameters()[parameter_name].required === true) // Only include mandatory parameters
        ;
        if (parameter_names.length > 0) {
            parameter_indicator = Variable.parameter_separator; // When the variable name ends with a parameter separator character, it indicates to a user that an argument should be supplied.
        }
        return [
            // Normal variable
            {
                value: "{{" + this.variable_name + parameter_indicator + "}}",
                help_text: (this.help_text + " " + this.getAvailabilityText()).trim(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped version of the variable
            {
                value: "{{!" + this.variable_name + parameter_indicator + "}}",
                help_text: (this.help_text + " " + this.getAvailabilityText()).trim(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>" + this.getFullName() + "</strong>";
    }
    /**
     * Returns the Variable's name wrapped in {{ and }}.
     *
     * TODO: Change hardcoded {{ }} entries to use this method all around the code.
     */
    getFullName() {
        return "{{" + this.variable_name + "}}";
    }
    /**
     * TODO: Create a class BuiltinVariable and move this method there. This should not be present for CustomVariables.
     */
    getDocumentationLink() {
        return DocumentationBuiltInVariablesBaseLink + encodeURI(this.getFullName());
    }
    /**
     * TODO: Create a class BuiltinVariable and move this method there. This should not be present for CustomVariables.
     */
    createDocumentationLinkElement(container) {
        const description = this.getFullName() + ": " + this.help_text
            + os.EOL + os.EOL +
            "Click for external documentation.";
        container.createEl("a", {
            text: this.getFullName(),
            href: this.getDocumentationLink(),
            attr: { "aria-label": description },
        });
    }
    /**
     * Returns a unique string that can be used in default value configurations.
     * @return Normal variable name, if this is a built-in variable; or an ID string if this is a CustomVariable.
     */
    getIdentifier() {
        return this.getFullName();
    }
    /**
     * This can be used to determine if the variable can sometimes be unavailable. Used in settings to allow a user to define
     * default values for variables that are not always available, filtering out always available variables for which default
     * values would not make sense.
     */
    isAlwaysAvailable() {
        return this.always_available;
    }
    /**
     * For variables that are always available, returns an empty string.
     */
    getAvailabilityText() {
        return "";
    }
    /**
     * Same as getAvailabilityText(), but removes HTML from the result.
     */
    getAvailabilityTextPlain() {
        return this.getAvailabilityText().replace(/<\/?strong>/ig, ""); // Remove <strong> and </strong> markings from the help text
    }
    /**
     * Returns a default value configuration object that should be used if a shell command does not define its own
     * default value configuration object.
     */
    getGlobalDefaultValueConfiguration() {
        // Works for built-in variables only. CustomVariable class needs to override this method and not call the parent!
        return this.plugin.settings.builtin_variables[this.getIdentifier()]?.default_value; // Can return null
    }
}
Variable.parameter_separator = ":";
/**
 * A definition for what parameters this variables takes.
 * @protected
 */
Variable.parameters = {};
/**
 * Thrown when Variables encounter errors that users should solve. Variable.getValue() will catch these and show to user
 * (unless errors are ignored).
 */
class VariableError extends Error {
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_Output extends Variable {
    constructor(plugin, output_content) {
        super(plugin);
        this.output_content = output_content;
        this.variable_name = "output";
        this.help_text = "Gives text outputted by a shell command after it's executed.";
    }
    async generateValue() {
        return this.output_content;
    }
    getAvailabilityText() {
        return "<strong>Only available</strong> in <em>output wrappers</em>, cannot be used as input for shell commands.";
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Escaper {
    constructor(raw_value) {
        this.raw_value = raw_value;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * Prefixes all characters that are not letters, numbers or underscores with a prefix character that can be defined by child classes.
 */
class AllSpecialCharactersEscaper extends Escaper {
    escape() {
        return this.raw_value.replace(/[^\w\d]/gu, (special_character) => {
            // Do the replacing in a function in order to avoid a possible $ character to be interpreted by JavaScript to interact with the regex.
            // More information: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter (referenced 2021-11-02.
            return this.prefix + special_character;
        });
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class ShEscaper extends AllSpecialCharactersEscaper {
    constructor() {
        super(...arguments);
        this.prefix = "\\"; // In *sh, escaping should use a backslash, e.g. "Hello, world!" becomes \"Hello\,\ world\!\"
    }
    escape() {
        return this.replace_newlines(super.escape());
    }
    /**
     * Converts escaped newline characters to a form that the Bourne family shells will interpret as literal newlines,
     * not as ignorable characters.
     *
     * @param escaped_value
     * @private
     */
    replace_newlines(escaped_value) {
        return escaped_value
            .replaceAll(this.prefix + "\r", this.prefix + this.prefix + "r") // Replace a real linefeed with a literal "\\r".
            .replaceAll(this.prefix + "\n", this.prefix + this.prefix + "n") // Replace a real newline with a literal "\\n".
        ;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class PowerShellEscaper extends AllSpecialCharactersEscaper {
    constructor() {
        super(...arguments);
        this.prefix = "`"; // In PowerShell, escaping should use a ` character, e.g. "Hello, world!" becomes `"Hello`,` world`!`"
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function escapeValue(shell, raw_value) {
    shell = extractFileName(shell.toLowerCase());
    let escaper;
    switch (shell) {
        case "bash":
        case "dash":
        case "zsh":
        case "sh": // May sometimes appear when using the "Use system default (sh)" option as a default shell.
            escaper = new ShEscaper(raw_value);
            break;
        case "powershell.exe": // PowerShell 5 is only available for Windows.
        case "pwsh.exe": // In Windows.
        case "pwsh": // In Linux and Mac. (SC does not actually support using PowerShell on Linux/Mac just yet, but support can be added).
            escaper = new PowerShellEscaper(raw_value);
            break;
        case "cmd.exe":
            // Exception: There is no escaping support for CMD, so all values will be left unescaped when CMD is used. :(
            return raw_value;
        default:
            // Shell was not recognised.
            new obsidian.Notice("EscapeValue(): Unrecognised shell: " + shell);
            throw new Error("EscapeValue(): Unrecognised shell: " + shell);
    }
    return escaper.escape();
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_Clipboard extends Variable {
    constructor() {
        super(...arguments);
        this.variable_name = "clipboard";
        this.help_text = "Gives the content you last copied to your clipboard.";
    }
    async generateValue() {
        return electron.clipboard.readText();
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class EditorVariable extends Variable {
    constructor() {
        super(...arguments);
        this.always_available = false;
    }
    getEditorOrThrow() {
        const editor = getEditor(this.app);
        if (null === editor) {
            // No editor.
            this.throw("Could not get an editor instance! Please create a discussion in GitHub.");
        }
        return editor;
    }
    /**
     * Can be made protected if needed to be accessed by subclasses.
     * @private
     */
    getViewOrThrow() {
        const view = getView(this.app);
        if (null === view) {
            // No view.
            this.throw("Could not get a view instance! Please create a discussion in GitHub.");
        }
        return view;
    }
    requireViewModeSource() {
        const view = this.getViewOrThrow();
        const view_mode = view.getMode(); // "preview" or "source" ("live" was removed from Obsidian API in 0.13.8 on 2021-12-10).
        switch (view_mode) {
            case "preview":
                // The leaf is in preview mode, which makes things difficult.
                // FIXME: Make it possible to use this feature also in preview mode.
                debugLog("EditorVariable: 'view' is in preview mode, and the poor guy who wrote this code, does not know how to return an editor instance that could be used for getting text selection.");
                this.throw("You need to turn editing mode on, unfortunately this variable does not work in preview mode.");
                break;
            case "source":
                // Good, the editor is in "source" mode, so it's possible to get a selection, caret position or other editing related information.
                return;
            default:
                this.throw("Unrecognised view mode: " + view_mode);
                break;
        }
    }
    getAvailabilityText() {
        return "<strong>Only available</strong> when a note pane is open, not in graph view, nor when viewing non-text files.";
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact:
 *  - Vinay Rajur: https://github.com/vrajur
 *  - Jarkko Linnanvirta: https://github.com/Taitava/
 */
class Variable_CaretPosition extends EditorVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "caret_position";
        this.help_text = "Gives the line number and column position of the current caret position as 'line:column'. Get only the line number using {{caret_position:line}}, and only the column with {{caret_position:column}}. Line and column numbers are 1-indexed.";
    }
    async generateValue(castedArguments) {
        // Check that we are able to get an editor
        const editor = this.getEditorOrThrow();
        const position = editor.getCursor('to');
        const line = position.line + 1; // editor position is zero-indexed, line numbers are 1-indexed
        const column = position.ch + 1; // editor position is zero-indexed, column positions are 1-indexed
        if (undefined !== castedArguments.mode) {
            switch (castedArguments.mode.toLowerCase()) {
                case "line":
                    return `${line}`;
                case "column":
                    return `${column}`;
                default:
                    this.throw("Unrecognised argument: " + castedArguments.mode);
            }
        }
        else {
            // default case when no args provided
            return `${line}:${column}`;
        }
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + "}}",
                help_text: "Gives the line number and column position of the current caret position as 'line:column'. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":line}}",
                help_text: "Gives the line number of the current caret position. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":column}}",
                help_text: "Gives the column number of the current caret position. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + "}}",
                help_text: "Gives the line number and column position of the current caret position as 'line:column'. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":line}}",
                help_text: "Gives the line number of the current caret position. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":column}}",
                help_text: "Gives the column number of the current caret position. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{caret_position}}</strong>, <strong>{{caret_position:line}}</strong> or <strong>{{caret_position:column}}</strong>";
    }
    getAvailabilityText() {
        return super.getAvailabilityText() + " Not available in preview mode.";
    }
}
Variable_CaretPosition.parameters = {
    mode: {
        options: ["line", "column"],
        required: false,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_Date extends Variable {
    constructor() {
        super(...arguments);
        this.variable_name = "date";
        this.help_text = "Gives a date/time stamp as per your liking. The \"format\" part can be customized and is mandatory. Formatting options: https://momentjs.com/docs/#/displaying/format/";
    }
    async generateValue(castedArguments) {
        return obsidian.moment().format(castedArguments.format);
    }
}
Variable_Date.parameters = {
    format: {
        type: "string",
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * TODO: Consider creating a decorator class for TFolder and moving this function to be a method in it.
 *
 * @param app
 * @param folder
 * @param mode
 */
function getFolderPath(app, folder, mode) {
    switch (mode.toLowerCase()) {
        case "absolute":
            return normalizePath2(getVaultAbsolutePath(app) + "/" + folder.path);
        case "relative":
            if (folder.isRoot()) {
                // Obsidian API does not give a correct folder.path value for the vault's root folder.
                // TODO: See this discussion and apply possible changes if something will come up: https://forum.obsidian.md/t/vault-root-folders-relative-path-gives/24857
                return ".";
            }
            else {
                // This is a normal subfolder
                return normalizePath2(folder.path); // Normalize to get a correct slash between directories depending on platform. On Windows it should be \ .
            }
    }
}
/**
 * TODO: Consider creating a decorator class for TFile and moving this function to be a method in it.
 *
 * @param app
 * @param file
 * @param mode
 */
function getFilePath(app, file, mode) {
    switch (mode.toLowerCase()) {
        case "absolute":
            return normalizePath2(getVaultAbsolutePath(app) + "/" + file.path);
        case "relative":
            return normalizePath2(file.path); // Normalize to get a correct slash depending on platform. On Windows it should be \ .
    }
}
/**
 * TODO: Consider creating a decorator class for TFile and moving this function to be a method in it.
 * @param file
 * @param with_dot
 */
function getFileExtension(file, with_dot) {
    const file_extension = file.extension;
    // Should the extension be given with or without a dot?
    if (with_dot) {
        // A preceding dot must be included.
        if (file_extension.length > 0) {
            // But only if the extension is not empty.
            return "." + file_extension;
        }
    }
    // No dot should be included, or the extension is empty
    return file_extension;
}
function getFileTags(app, file) {
    const cache = app.metadataCache.getFileCache(file);
    if (!cache) {
        throw new Error("Could not get metadata cache.");
    }
    // Get tags. May include duplicates, if a tag is defined multiple times in the same file.
    const tagsIncludingDuplicates = obsidian.getAllTags(cache) ?? []; // ?? [] = in case null is returned, convert it to an empty array. I have no clue in which situation this might happen. Maybe if the file does not contain any tags?
    // Iron out possible duplicates.
    const tagsWithoutDuplicates = uniqueArray(tagsIncludingDuplicates);
    // Remove preceding hash characters. E.g. #tag becomes tag
    tagsWithoutDuplicates.forEach((tag, index) => {
        tagsWithoutDuplicates[index] = tag.replace("#", "");
    });
    return tagsWithoutDuplicates;
}
/**
 * @param app
 * @param file
 * @param property_path
 * @return string|string[] Either a result string, or an array of error messages.
 */
function getFileYAMLValue(app, file, property_path) {
    const error_messages = [];
    const property_parts = property_path.split(".");
    // Validate all property names along the path
    property_parts.forEach((property_name) => {
        if (0 === property_name.length) {
            error_messages.push("YAML property '" + property_path + "' has an empty property name. Remove possible double dots or a preceding/trailing dot.");
        }
    });
    if (error_messages.length > 0) {
        // Failure in property name(s).
        return error_messages;
    }
    const frontmatter = app.metadataCache.getFileCache(file)?.frontmatter;
    // Check that a YAML section is available in the file
    if (undefined === frontmatter) {
        // No it ain't.
        error_messages.push("No YAML frontmatter section is defined for the current file.");
        return error_messages;
    }
    else {
        // A YAML section is available.
        // Read the property's value.
        return nested_read(property_parts, property_path, frontmatter);
    }
    /**
     * @param property_parts Property path split into parts (= property names). The deeper the nesting goes, the fewer values will be left in this array. This should always contain at least one part! If not, an Error is thrown.
     * @param property_path The original, whole property path string.
     * @param yaml_object
     * @return string|string[] Either a result string, or an array of error messages.
     */
    function nested_read(property_parts, property_path, yaml_object) {
        // Check that property_parts contains at least one part.
        if (property_parts.length === 0) {
            throw new Error("No more property parts to read!");
        }
        let property_name = property_parts.shift(); // as string: Tell TypeScript that the result is not undefined, because the array is not empty.
        // Check if the property name is a negative numeric index.
        if (property_name.match(/^-\d+$/u)) {
            // The property name is a negative number.
            // Check that yaml_object contains at least one element.
            const yaml_object_keys = Object.getOwnPropertyNames(yaml_object).filter(key => key !== "length"); // All _really custom_ yaml keys, not .length
            if (yaml_object_keys.length > 0) {
                // Check if yaml_object happens to be an indexed list.
                let is_indexed_list = true;
                yaml_object_keys.forEach((key) => {
                    if (!key.match(/^\d+$/u)) {
                        // At least one non-numeric key was found, so consider the object not to be an indexed list.
                        is_indexed_list = false;
                    }
                });
                if (is_indexed_list) {
                    // The object is an indexed list and property_name is a negative index number.
                    // Translate property_name to a positive index from the end of the list.
                    property_name = Math.max(0, // If a greatly negative index is used (e.g. -999), don't allow the new index to be negative again.
                    yaml_object_keys.length
                        + parseInt(property_name) // Although + is used, this will be a subtraction, because property_name is prefixed with a minus.
                    ).toString();
                }
            }
        }
        // Get a value
        const property_value = yaml_object[property_name];
        // Check if the value is either: not found, object, or literal.
        if (undefined === property_value) {
            // Property was not found.
            error_messages.push("YAML property '" + property_name + "' is not found.");
            return error_messages;
        }
        else if (null === property_value) {
            // Property is found, but has an empty value. Example:
            //   ---
            //   itemA: valueA
            //   itemB:
            //   itemC: valueC
            //   ---
            // Here `itemB` would have a null value.
            error_messages.push("YAML property '" + property_name + "' has a null value. Make sure the property is not accidentally left empty.");
            return error_messages;
        }
        else if ("object" === typeof property_value) {
            // The value is an object.
            // Check if we have still dot notation parts left in the property path.
            if (0 === property_parts.length) {
                // No dot notation parts are left.
                // Freak out.
                const nested_elements_keys = Object.getOwnPropertyNames(property_value);
                if (nested_elements_keys.length > 0) {
                    error_messages.push("YAML property '" + property_name + "' contains a nested element with keys: " + nested_elements_keys.join(", ") + ". Use e.g. '" + property_path + "." + nested_elements_keys[0] + "' to get its value.");
                }
                else {
                    error_messages.push("YAML property '" + property_name + "' contains a nested element. Use a property name that points to a literal value instead.");
                }
                return error_messages;
            }
            else {
                // Dot notation path still has another property name left, so continue the hunt.
                return nested_read(property_parts, property_path, property_value);
            }
        }
        else {
            // The value is literal, i.e. a string or number.
            if (property_parts.length > 0) {
                error_messages.push("YAML property '" + property_name + "' gives already a literal value '" + property_value.toString() + "', but the argument '" + property_path + "' assumes the property would contain a nested element with the key '" + property_parts[0] + "'.");
                return error_messages;
            }
            else {
                return property_value.toString();
            }
        }
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class FileVariable extends Variable {
    constructor() {
        super(...arguments);
        this.always_available = false;
    }
    getFileOrThrow() {
        const currentFile = this.app.workspace.getActiveFile();
        if (!currentFile) {
            this.throw("No file is active at the moment. Open a file or click a pane that has a file open.");
        }
        return currentFile;
    }
    getAvailabilityText() {
        return "<strong>Only available</strong> when the active pane contains a file, not in graph view or other non-file view.";
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_FileExtension extends FileVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "file_extension";
        this.help_text = "Gives the current file name's ending. Use {{file_extension:with-dot}} to include a preceding dot. If the extension is empty, no dot is added. {{file_extension:no-dot}} never includes a dot.";
    }
    async generateValue(castedArguments) {
        return getFileExtension(this.getFileOrThrow(), castedArguments.dot === "with-dot");
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":no-dot}}",
                help_text: "Gives the current file name's ending without a preceding dot. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":with-dot}}",
                help_text: "Gives the current file name's ending with a preceding dot. If the extension is empty, no dot is included. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":no-dot}}",
                help_text: "Gives the current file name's ending without a preceding dot. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":with-dot}}",
                help_text: "Gives the current file name's ending with a preceding dot. If the extension is empty, no dot is included. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{file_extension:with-dot}}</strong> or <strong>{{file_extension:no-dot}}</strong>";
    }
}
Variable_FileExtension.parameters = {
    "dot": {
        options: ["with-dot", "no-dot"],
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_FileName extends FileVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "file_name";
        this.help_text = "Gives the current file name with a file extension. If you need it without the extension, use {{title}} instead.";
    }
    async generateValue() {
        return this.getFileOrThrow().name;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_FilePath extends FileVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "file_path";
        this.help_text = "Gives path to the current file, either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.";
    }
    async generateValue(castedArguments) {
        return getFilePath(this.app, this.getFileOrThrow(), castedArguments.mode);
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":absolute}}",
                help_text: "Gives path to the current file, absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":relative}}",
                help_text: "Gives path to the current file, relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":absolute}}",
                help_text: "Gives path to the current file, absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":relative}}",
                help_text: "Gives path to the current file, relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{file_path:relative}}</strong> or <strong>{{file_path:absolute}}</strong>";
    }
}
Variable_FilePath.parameters = {
    mode: {
        options: ["absolute", "relative"],
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class FolderVariable extends FileVariable {
    getFolderOrThrow() {
        // Get current file's parent folder.
        const file = this.getFileOrThrow();
        const currentFolder = file.parent;
        if (!currentFolder) {
            // No parent folder.
            this.throw("The current file does not have a parent for some strange reason.");
        }
        return currentFolder;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_FolderName extends FolderVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "folder_name";
        this.help_text = "Gives the current file's parent folder name, or a dot if the folder is the vault's root. No ancestor folders are included.";
    }
    async generateValue() {
        const folder = this.getFolderOrThrow();
        return folder.isRoot()
            ? "." // Return a dot instead of an empty string.
            : folder.name;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_FolderPath extends FolderVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "folder_path";
        this.help_text = "Gives path to the current file's parent folder, either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.";
    }
    async generateValue(castedArguments) {
        return getFolderPath(this.app, this.getFolderOrThrow(), castedArguments.mode);
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":absolute}}",
                help_text: "Gives path to the current file's parent folder, absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":relative}}",
                help_text: "Gives path to the current file's parent folder, relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":absolute}}",
                help_text: "Gives path to the current file's parent folder, absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":relative}}",
                help_text: "Gives path to the current file's parent folder, relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{folder_path:relative}}</strong> or <strong>{{folder_path:absolute}}</strong>";
    }
}
Variable_FolderPath.parameters = {
    mode: {
        options: ["absolute", "relative"],
        required: true,
    }
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_Selection extends EditorVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "selection";
        this.help_text = "Gives the currently selected text.";
    }
    async generateValue() {
        // Check that we are able to get an editor
        const editor = this.getEditorOrThrow();
        // Check the view mode
        this.requireViewModeSource();
        // Good, the editor is in "source" mode, so it's possible to get a selection.
        if (editor.somethingSelected()) {
            return editor.getSelection();
        }
        this.throw("Nothing is selected. " + os.EOL + os.EOL + "(This error message was added in SC 0.18.0. Earlier the variable gave an empty text in this situation. If you want to restore the old behavior, go to SC settings, then to Variables tab, and define a default value for {{selection}}.)");
    }
    getAvailabilityText() {
        return "<strong>Only available</strong> when something is selected in <em>Editing</em>/<em>Live preview</em> mode, <strong>not</strong> in <em>Reading</em> mode.";
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_Tags extends FileVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "tags";
        this.help_text = "Gives all tags defined in the current note. Replace the \"separator\" part with a comma, space or whatever characters you want to use as a separator between tags. A separator is always needed to be defined.";
    }
    async generateValue(castedArguments) {
        return getFileTags(this.app, this.getFileOrThrow()).join(castedArguments.separator);
    }
}
Variable_Tags.parameters = {
    separator: {
        type: "string",
        required: true,
    }
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_Title extends FileVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "title";
        this.help_text = "Gives the current file name without a file extension. If you need it with the extension, use {{file_name}} instead.";
    }
    async generateValue() {
        return this.getFileOrThrow().basename;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_VaultPath extends Variable {
    constructor() {
        super(...arguments);
        this.variable_name = "vault_path";
        this.help_text = "Gives the Obsidian vault's absolute path from the root of the filesystem. This is the same that is used as a default working directory if you do not define one manually. If you define a working directory manually, this variable won't give you your manually defined directory, it always gives the vault's root directory.";
    }
    async generateValue() {
        return getVaultAbsolutePath(this.app);
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_Workspace extends Variable {
    constructor() {
        super(...arguments);
        this.variable_name = "workspace";
        this.help_text = "Gives the current workspace's name.";
        this.always_available = false;
    }
    async generateValue() {
        // Idea how to access the workspaces plugin is copied 2021-09-15 from https://github.com/Vinzent03/obsidian-advanced-uri/blob/f7ef80d5252481242e69496208e925874209f4aa/main.ts#L168-L179
        // @ts-ignore internalPlugins exists, although it's not in obsidian.d.ts.
        const workspaces_plugin = this.app.internalPlugins?.plugins?.workspaces;
        if (!workspaces_plugin) {
            this.throw("Workspaces core plugin is not found for some reason. Please create a discussion in GitHub.");
        }
        else if (!workspaces_plugin.enabled) {
            this.throw("Workspaces core plugin is not enabled.");
        }
        const workspace_name = workspaces_plugin.instance?.activeWorkspace;
        if (!workspace_name) {
            this.throw("Could not figure out the current workspace's name. Probably you have not loaded a workspace. You can do it e.g. via \"Manage workspaces\" from the left side panel.");
        }
        // All ok
        return workspace_name;
    }
    getAvailabilityText() {
        return "<strong>Only available</strong> when the Workspaces core plugin is enabled.";
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_Passthrough extends Variable {
    constructor() {
        super(...arguments);
        this.variable_name = "passthrough";
        this.help_text = "Gives the same value that is passed as an argument. Used for testing special characters' escaping.";
    }
    async generateValue(castedArguments) {
        // Simply return the argument that was received.
        return castedArguments.value;
    }
    getAvailabilityText() {
        return "<strong>Only available</strong> in debug mode.";
    }
}
Variable_Passthrough.parameters = {
    value: {
        type: "string",
        required: true,
    }
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_YAMLValue extends FileVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "yaml_value";
        this.help_text = "Reads a single value from the current file's frontmatter. Takes a property name as an argument. You can access nested properties with dot notation: property1.property2";
    }
    async generateValue(castedArguments) {
        // We do have an active file
        const result = getFileYAMLValue(this.app, this.getFileOrThrow(), castedArguments.property_name);
        if (Array.isArray(result)) {
            // The result contains error message(s).
            this.throw(result.join(" "));
        }
        else {
            // The result is ok, it's a string.
            return result;
        }
    }
    getAvailabilityText() {
        return super.getAvailabilityText() + " Also, the given YAML property must exist in the file's frontmatter.";
    }
    getHelpName() {
        return "<strong>{{yaml_value:property}}</strong>";
    }
}
Variable_YAMLValue.parameters = {
    property_name: {
        type: "string",
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class EventVariable extends Variable {
    constructor() {
        super(...arguments);
        this.always_available = false;
    }
    /**
     * Every subclass should call this method in their generateValue() before generating a value. This method will throw
     * a VariableError if an incompatible SC_Event is tried to be used with this {{variable}}.
     *
     * @protected
     */
    requireCorrectEvent(sc_event) {
        // 1. Check generally that an event is happening.
        // (Maybe this check is not so important anymore, as sc_event is now received as a parameter instead of from a property, but check just in case.)
        if (!sc_event) {
            this.throw("This variable can only be used during events: " + this.getSummaryOfSupportedEvents());
        }
        // 2. Check particularly which event it is.
        if (!this.supportsSC_Event(sc_event.getClass())) {
            this.throw("This variable does not support event '" + sc_event.static().getTitle() + "'. Supported events: " + this.getSummaryOfSupportedEvents());
        }
    }
    supportsSC_Event(sc_event_class) {
        return this.supported_sc_events.contains(sc_event_class);
    }
    getSummaryOfSupportedEvents() {
        const sc_event_titles = [];
        this.supported_sc_events.forEach((sc_event_class) => {
            sc_event_titles.push(sc_event_class.getTitle());
        });
        return sc_event_titles.join(", ");
    }
    getAvailabilityText() {
        return "<strong>Only available</strong> in events: " + this.getSummaryOfSupportedEvents() + ".";
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * Named SC_Event instead of just Event, because Event is a class in JavaScript.
 */
class SC_Event {
    constructor(plugin) {
        /**
         * If true, changing the enabled/disabled status of the event permits registering the event immediately, so it can activate
         * anytime. Usually true, but can be set to false if immediate registering tends to trigger the event unnecessarily.
         *
         * Events are always registered when loading the plugin, regardless of this property.
         * @protected
         */
        this.register_after_changing_settings = true;
        this.event_registrations = {};
        this.default_configuration = {
            enabled: false,
        };
        this.plugin = plugin;
        this.app = plugin.app;
        this.subclass_instance = this; // Stores a subclass reference, not a base class reference.
    }
    getClass() {
        return this.subclass_instance.constructor;
    }
    canRegisterAfterChangingSettings() {
        return this.register_after_changing_settings;
    }
    register(t_shell_command) {
        const event_reference = this._register(t_shell_command);
        if (event_reference) {
            this.plugin.registerEvent(event_reference);
            this.event_registrations[t_shell_command.getId()] = event_reference;
        }
    }
    unregister(t_shell_command) {
        // Check if an EventRef is available.
        if (undefined === this.event_registrations[t_shell_command.getId()]) {
            // The event was registered without an EventRef object.
            // Provide a TShellCommand to _unregister() so it can do a custom unregistering.
            this._unregister(t_shell_command);
        }
        else {
            // The event registration had created an EventRef object.
            // Provide the EventRef to _unregister() and forget it afterwards.
            this._unregister(this.event_registrations[t_shell_command.getId()]);
            delete this.event_registrations[t_shell_command.getId()];
        }
    }
    /**
     * Executes a shell command.
     * @param t_shell_command
     * @param parsing_process SC_MenuEvent can use this to pass an already started ParsingProcess instance. If omitted, a new ParsingProcess will be created.
     */
    async trigger(t_shell_command, parsing_process) {
        // Execute the shell command.
        const executor = new ShellCommandExecutor(this.plugin, t_shell_command, this);
        await executor.doPreactionsAndExecuteShellCommand(parsing_process);
    }
    static getCode() {
        return this.event_code;
    }
    static getTitle() {
        return this.event_title;
    }
    /**
     * Creates a list of variables to the given container element. Each variable is a link to its documentation.
     *
     * @param container
     * @return A boolean indicating whether anything was created or not. Not all SC_Events utilise event variables.
     */
    createSummaryOfEventVariables(container) {
        let hasCreatedElements = false;
        this.getEventVariables().forEach((variable) => {
            if (hasCreatedElements) {
                container.insertAdjacentText("beforeend", ", ");
            }
            hasCreatedElements = true;
            variable.createDocumentationLinkElement(container);
        });
        return hasCreatedElements;
    }
    getEventVariables() {
        const event_variables = [];
        this.plugin.getVariables().forEach((variable) => {
            // Check if the variable is an EventVariable
            if (variable instanceof EventVariable) {
                // Yes it is.
                // Check if the variable supports this particular event.
                if (variable.supportsSC_Event(this.getClass())) {
                    // Yes it supports.
                    event_variables.push(variable);
                }
            }
        });
        return event_variables;
    }
    /**
     * Can be overridden in child classes that need custom settings fields.
     *
     * @param enabled
     */
    getDefaultConfiguration(enabled) {
        const configuration = cloneObject(this.default_configuration);
        configuration.enabled = enabled;
        return configuration;
    }
    getConfiguration(t_shell_command) {
        return t_shell_command.getEventConfiguration(this);
    }
    /**
     * Can be overridden in child classes to provide custom configuration fields for ShellCommandsExtraOptionsModal.
     *
     * @param extra_settings_container
     */
    createExtraSettingsFields(extra_settings_container, t_shell_command) {
        // Most classes do not define custom settings, so for those classes this method does not need to do anything.
    }
    /**
     * Returns all the TShellCommand instances that have enabled this event.
     */
    getTShellCommands() {
        const enabled_t_shell_commands = [];
        Object.values(this.plugin.getTShellCommands()).forEach((t_shell_command) => {
            // Check if this event has been enabled for the shell command.
            if (t_shell_command.isSC_EventEnabled(this.static().event_code)) {
                // Yes, it's enabled.
                enabled_t_shell_commands.push(t_shell_command);
            }
        });
        return enabled_t_shell_commands;
    }
    static() {
        return this.constructor;
    }
    /**
     * Child classes can override this to hook into a situation where a user has enabled an event in settings.
     *
     * @param t_shell_command The TShellCommand instance for which this SC_Event was enabled for.
     */
    onAfterEnabling(t_shell_command) {
        // If an SC_Event does not override this hook method, do nothing.
    }
    static getDocumentationLink() {
        return DocumentationEventsFolderLink + encodeURIComponent(this.event_title);
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_WorkspaceEvent extends SC_Event {
    _register(t_shell_command) {
        // @ts-ignore TODO: Find a way to get a dynamic type for this.workspace_event .
        return this.app.workspace.on(this.workspace_event, this.getTrigger(t_shell_command));
    }
    _unregister(event_reference) {
        this.app.workspace.offref(event_reference);
    }
    getTrigger(t_shell_command) {
        return async (...parameters /* Need to have this ugly parameter thing so that subclasses can define their own parameters. */) => await this.trigger(t_shell_command);
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_MenuEvent extends SC_WorkspaceEvent {
    async addTShellCommandToMenu(t_shell_command, menu) {
        // Create the menu item as soon as possible. (If it's created after 'await parsing_process.process()' below, it won't be shown in the menu for some reason, at least in Obsidian 0.16.1).
        menu.addItem(async (menuItem) => {
            // Parse shell command variables to get a title
            let title = t_shell_command.getAliasOrShellCommand(); // May contain unparsed variables.
            let parsing_process;
            if (this.plugin.settings.preview_variables_in_command_palette) {
                // Start a parsing process
                parsing_process = t_shell_command.createParsingProcess(this);
                if (await parsing_process.process()) {
                    // Parsing succeeded.
                    const parsing_results = parsing_process.getParsingResults();
                    const aliasParsingResult = parsing_results["alias"]; // as ParsingResult: Tells TypeScript that the object exists.
                    const shellCommandParsingResult = parsing_results["shell_command"]; // as ParsingResult: Tells TypeScript that the object exists.
                    title = aliasParsingResult.parsed_content || shellCommandParsingResult.parsed_content; // Try to use a parsed alias, but if no alias is available, use a parsed shell command instead. as string = parsed shell command always exist when the parsing itself has succeeded.
                }
                // If parsing process fails, the failed process can be passed to this.trigger(). The execution will eventually be cancelled and error messages displayed (if displaying is allowed).
            }
            // Set menu item title - be it parsed or not.
            menuItem.setTitle(title);
            // Icon and onClick handler.
            menuItem
                .setIcon(t_shell_command.getIconId()) // Icon id can be null.
                .onClick(async () => {
                await this.trigger(t_shell_command, parsing_process);
            });
        });
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_AbstractFileMenuEvent extends SC_MenuEvent {
    constructor() {
        super(...arguments);
        this.workspace_event = "file-menu";
    }
    getTrigger(t_shell_command) {
        return async (menu, file, source, leaf) => {
            // Check that it's the correct menu: if the SC_Event requires a file menu, 'file' needs to be a TFile, otherwise it needs to be a TFolder.
            if ((this.file_or_folder === "folder" && file instanceof obsidian.TFolder) || (this.file_or_folder === "file" && file instanceof obsidian.TFile)) {
                // The menu is correct.
                // File/folder for declareExtraVariables()
                switch (this.file_or_folder) {
                    case "file":
                        this.file = file;
                        break;
                    case "folder":
                        this.folder = file;
                        break;
                }
                await this.addTShellCommandToMenu(t_shell_command, menu);
            }
        };
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FileMenu extends SC_AbstractFileMenuEvent {
    constructor() {
        super(...arguments);
        this.file_or_folder = "file";
    }
    getFile() {
        return this.file;
    }
    getFolder() {
        return this.file.parent;
    }
}
SC_Event_FileMenu.event_code = "file-menu";
SC_Event_FileMenu.event_title = "File menu";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_VaultEvent extends SC_Event {
    _register(t_shell_command) {
        // @ts-ignore TODO: Find a way to get a dynamic type for this.vault_event .
        return this.app.vault.on(this.vault_event, this.getTrigger(t_shell_command));
    }
    _unregister(event_reference) {
        this.app.vault.offref(event_reference);
    }
    getTrigger(t_shell_command) {
        return async (file, ...extra_arguments /* Needed for SC_Event_FileRenamed and SC_Event_FolderRenamed to be able to define an additional parameter.*/) => {
            // Check that it's the correct type of file: if the SC_Event requires a file, 'file' needs to be a TFile, otherwise it needs to be a TFolder.
            if ((this.file_or_folder === "folder" && file instanceof obsidian.TFolder) || (this.file_or_folder === "file" && file instanceof obsidian.TFile)) {
                // The file type is correct.
                // File/folder for declareExtraVariables()
                switch (this.file_or_folder) {
                    case "file":
                        this.file = file;
                        break;
                    case "folder":
                        this.folder = file;
                        break;
                }
                await this.trigger(t_shell_command);
            }
        };
    }
    /**
     * This should only be called if file_or_folder is "file"!
     */
    getFile() {
        return this.file;
    }
    /**
     * This can be called whether file_or_folder is "file" or "folder".
     */
    getFolder() {
        switch (this.file_or_folder) {
            case "file":
                return this.file.parent;
            case "folder":
                return this.folder;
        }
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FileCreated extends SC_VaultEvent {
    constructor() {
        super(...arguments);
        this.vault_event = "create";
        this.file_or_folder = "file";
    }
}
SC_Event_FileCreated.event_code = "file-created";
SC_Event_FileCreated.event_title = "File created";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FileContentModified extends SC_VaultEvent {
    constructor() {
        super(...arguments);
        this.vault_event = "modify";
        this.file_or_folder = "file";
    }
}
SC_Event_FileContentModified.event_code = "file-content-modified";
SC_Event_FileContentModified.event_title = "File content modified";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FileDeleted extends SC_VaultEvent {
    constructor() {
        super(...arguments);
        this.vault_event = "delete";
        this.file_or_folder = "file";
    }
}
SC_Event_FileDeleted.event_code = "file-deleted";
SC_Event_FileDeleted.event_title = "File deleted";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_VaultMoveOrRenameEvent extends SC_VaultEvent {
    constructor() {
        super(...arguments);
        this.vault_event = "rename";
    }
    getTrigger(t_shell_command) {
        // Get a trigger from the parent class (SC_VaultEvent).
        const trigger = super.getTrigger(t_shell_command);
        return async (abstract_file, old_relative_path) => {
            // Detect if the file/folder was moved or renamed.
            // If the file/folder name has stayed the same, conclude that the file has been MOVED, not renamed. Otherwise, conclude the opposite.
            const old_file_name = extractFileName(old_relative_path);
            const new_file_name = abstract_file.name;
            const event_type = (old_file_name === new_file_name) ? "move" : "rename"; // Tells what really happened. this.move_or_rename tells what is the condition for the event to trigger.
            // Only proceed the triggering, if the determined type equals the one defined by the event class.
            if (event_type === this.move_or_rename) {
                // The event type is correct.
                // File and folder for declareExtraVariables()
                switch (this.file_or_folder) {
                    case "file":
                        this.file_old_relative_path = old_relative_path;
                        this.folder_old_relative_path = extractFileParentPath(old_relative_path);
                        break;
                    case "folder":
                        this.folder_old_relative_path = old_relative_path;
                        break;
                }
                // Call the normal trigger function.
                await trigger(abstract_file);
            }
        };
    }
    getFolderOldRelativePath() {
        return this.folder_old_relative_path;
    }
    getFileOldRelativePath() {
        return this.file_old_relative_path;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FileRenamed extends SC_VaultMoveOrRenameEvent {
    constructor() {
        super(...arguments);
        this.move_or_rename = "rename";
        this.file_or_folder = "file";
    }
}
SC_Event_FileRenamed.event_code = "file-renamed";
SC_Event_FileRenamed.event_title = "File renamed";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FileMoved extends SC_VaultMoveOrRenameEvent {
    constructor() {
        super(...arguments);
        this.move_or_rename = "move";
        this.file_or_folder = "file";
    }
}
SC_Event_FileMoved.event_code = "file-moved";
SC_Event_FileMoved.event_title = "File moved";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventFileName extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_file_name";
        this.help_text = "Gives the event related file name with a file extension. If you need it without the extension, use {{event_title}} instead.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(argumentsAreNotUsed, sc_event) {
        this.requireCorrectEvent(sc_event);
        return sc_event.getFile().name;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventFilePath extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_file_path";
        this.help_text = "Gives path to the event related file, either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(castedArguments, sc_event) {
        this.requireCorrectEvent(sc_event);
        return getFilePath(this.app, sc_event.getFile(), castedArguments.mode);
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":absolute}}",
                help_text: "Gives path to the event related file, absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":relative}}",
                help_text: "Gives path to the event related file, relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":absolute}}",
                help_text: "Gives path to the event related file, absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":relative}}",
                help_text: "Gives path to the event related file, relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{event_file_path:relative}}</strong> or <strong>{{event_file_path:absolute}}</strong>";
    }
}
Variable_EventFilePath.parameters = {
    mode: {
        options: ["absolute", "relative"],
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FolderMenu extends SC_AbstractFileMenuEvent {
    constructor() {
        super(...arguments);
        this.file_or_folder = "folder";
    }
    getFolder() {
        return this.folder;
    }
}
SC_Event_FolderMenu.event_code = "folder-menu";
SC_Event_FolderMenu.event_title = "Folder menu";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FolderCreated extends SC_VaultEvent {
    constructor() {
        super(...arguments);
        this.vault_event = "create";
        this.file_or_folder = "folder";
    }
}
SC_Event_FolderCreated.event_code = "folder-created";
SC_Event_FolderCreated.event_title = "Folder created";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FolderDeleted extends SC_VaultEvent {
    constructor() {
        super(...arguments);
        this.vault_event = "delete";
        this.file_or_folder = "folder";
    }
}
SC_Event_FolderDeleted.event_code = "folder-deleted";
SC_Event_FolderDeleted.event_title = "Folder deleted";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FolderRenamed extends SC_VaultMoveOrRenameEvent {
    constructor() {
        super(...arguments);
        this.move_or_rename = "rename";
        this.file_or_folder = "folder";
    }
}
SC_Event_FolderRenamed.event_code = "folder-renamed";
SC_Event_FolderRenamed.event_title = "Folder renamed";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_FolderMoved extends SC_VaultMoveOrRenameEvent {
    constructor() {
        super(...arguments);
        this.move_or_rename = "move";
        this.file_or_folder = "folder";
    }
}
SC_Event_FolderMoved.event_code = "folder-moved";
SC_Event_FolderMoved.event_title = "Folder moved";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventFolderName extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_folder_name";
        this.help_text = "File events: Gives the event related file's parent folder name. Folder events: Gives the selected folder's name. Gives a dot if the folder is the vault's root. No ancestor folders are included.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FolderMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
            SC_Event_FolderCreated,
            SC_Event_FolderDeleted,
            SC_Event_FolderMoved,
            SC_Event_FolderRenamed,
        ];
    }
    async generateValue(argumentsAreNotUsed, sc_event) {
        this.requireCorrectEvent(sc_event);
        const folder = sc_event.getFolder();
        return folder.isRoot()
            ? "." // Return a dot instead of an empty string.
            : folder.name;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventFolderPath extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_folder_path";
        this.help_text = "File events: Gives path to the event related file's parent folder. Folder events: Gives path to the event related folder. The path is either absolute from the root of the file system, or relative from the root of the Obsidian vault.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FolderMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
            SC_Event_FolderCreated,
            SC_Event_FolderDeleted,
            SC_Event_FolderMoved,
            SC_Event_FolderRenamed,
        ];
    }
    async generateValue(castedArguments, sc_event) {
        this.requireCorrectEvent(sc_event);
        return getFolderPath(this.app, sc_event.getFolder(), castedArguments.mode);
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":absolute}}",
                help_text: "File events: Gives path to the event related file's parent folder. Folder events: Gives path to the event related folder. The path is absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":relative}}",
                help_text: "File events: Gives path to the event related file's parent folder. Folder events: Gives path to the event related folder. The path is relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":absolute}}",
                help_text: "File events: Gives path to the event related file's parent folder. Folder events: Gives path to the event related folder. The path is absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":relative}}",
                help_text: "File events: Gives path to the event related file's parent folder. Folder events: Gives path to the event related folder. The path is relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{event_folder_path:relative}}</strong> or <strong>{{event_folder_path:absolute}}</strong>";
    }
}
Variable_EventFolderPath.parameters = {
    mode: {
        options: ["absolute", "relative"],
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventTitle extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_title";
        this.help_text = "Gives the event related file name without a file extension. If you need it with the extension, use {{event_file_name}} instead.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(argumentsAreNotUsed, sc_event) {
        this.requireCorrectEvent(sc_event);
        return sc_event.getFile().basename;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventFileExtension extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_file_extension";
        this.help_text = "Gives the event related file name's ending. Use {{event_file_extension:with-dot}} to include a preceding dot. If the extension is empty, no dot is added. {{event_file_extension:no-dot}} never includes a dot.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(castedArguments, sc_event) {
        this.requireCorrectEvent(sc_event);
        return getFileExtension(sc_event.getFile(), castedArguments.dot === "with-dot");
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":no-dot}}",
                help_text: "Gives the event related file name's ending without a preceding dot. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":with-dot}}",
                help_text: "Gives the event related file name's ending with a preceding dot. If the extension is empty, no dot is included. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":no-dot}}",
                help_text: "Gives the event related file name's ending without a preceding dot. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":with-dot}}",
                help_text: "Gives the event related file name's ending with a preceding dot. If the extension is empty, no dot is included. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{event_file_extension:with-dot}}</strong> or <strong>{{event_file_extension:no-dot}}</strong>";
    }
}
Variable_EventFileExtension.parameters = {
    "dot": {
        options: ["with-dot", "no-dot"],
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventTags extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_tags";
        this.help_text = "Gives all tags defined in the event related note. Replace the \"separator\" part with a comma, space or whatever characters you want to use as a separator between tags. A separator is always needed to be defined.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(castedArguments, sc_event) {
        this.requireCorrectEvent(sc_event);
        const file = sc_event.getFile();
        return getFileTags(this.app, file).join(castedArguments.separator);
    }
}
Variable_EventTags.parameters = {
    separator: {
        type: "string",
        required: true,
    }
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventYAMLValue extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_yaml_value";
        this.help_text = "Reads a single value from the event related file's frontmatter. Takes a property name as an argument. You can access nested properties with dot notation: property1.property2";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(castedArguments, sc_event) {
        this.requireCorrectEvent(sc_event);
        const result = getFileYAMLValue(this.app, sc_event.getFile(), castedArguments.property_name);
        if (Array.isArray(result)) {
            // The result contains error message(s).
            this.throw(result.join(" "));
        }
        else {
            // The result is ok, it's a string.
            return result;
        }
    }
    getAvailabilityText() {
        return super.getAvailabilityText() + " Also, the given YAML property must exist in the file's frontmatter.";
    }
    getHelpName() {
        return "<strong>{{event_yaml_value:property}}</strong>";
    }
}
Variable_EventYAMLValue.parameters = {
    property_name: {
        type: "string",
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_Environment extends Variable {
    constructor() {
        super(...arguments);
        this.variable_name = "environment";
        this.help_text = "Gives an environment variable's value. It's an original value received when Obsidian was started.";
        this.always_available = false;
    }
    async generateValue(castedArguments) {
        // Check that the requested environment variable exists.
        if (undefined !== process.env[castedArguments.variable]) {
            // Yes, it exists.
            return process.env[castedArguments.variable]; // as string: tells TypeScript compiler that the item exists, is not undefined.
        }
        else {
            // It does not exist.
            // Freak out.
            this.throw(`Environment variable named '${castedArguments.variable}' does not exist.`);
        }
    }
    getHelpName() {
        return "<strong>{{environment:variable}}</strong>";
    }
    getAvailabilityText() {
        return "<strong>Only available</strong> if the passed environment variable name exists.";
    }
}
Variable_Environment.parameters = {
    variable: {
        type: "string",
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventOldFileName extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_old_file_name";
        this.help_text = "Gives the renamed file's old name with a file extension. If you need it without the extension, use {{event_old_title}} instead.";
        this.supported_sc_events = [
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(argumentsAreNotUsed, sc_event) {
        this.requireCorrectEvent(sc_event);
        return extractFileName(sc_event.getFileOldRelativePath(), true);
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventOldFilePath extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_old_file_path";
        this.help_text = "Gives the renamed/moved file's old path, either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.";
        this.supported_sc_events = [
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(castedArguments, sc_event) {
        this.requireCorrectEvent(sc_event);
        const file_old_relative_path = sc_event.getFileOldRelativePath();
        switch (castedArguments.mode.toLowerCase()) {
            case "relative":
                return normalizePath2(file_old_relative_path);
            case "absolute":
                return normalizePath2(getVaultAbsolutePath(this.app) + "/" + file_old_relative_path);
        }
        this.throw("Unrecognized mode parameter: " + castedArguments.mode);
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":absolute}}",
                help_text: "Gives the renamed/moved file's old path, absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":relative}}",
                help_text: "Gives the renamed/moved file's old path, relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":absolute}}",
                help_text: "Gives the renamed/moved file's old path, absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":relative}}",
                help_text: "Gives the renamed/moved file's old path, relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{event_file_path:relative}}</strong> or <strong>{{event_file_path:absolute}}</strong>";
    }
}
Variable_EventOldFilePath.parameters = {
    mode: {
        options: ["absolute", "relative"],
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventOldFolderName extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_old_folder_name";
        this.help_text = "File events: Gives the moved file's old parent folder's name. Folder events: Gives the renamed folder's old name.";
        this.supported_sc_events = [
            SC_Event_FileMoved,
            SC_Event_FolderRenamed,
        ];
    }
    async generateValue(argumentsAreNotUsed, sc_event) {
        this.requireCorrectEvent(sc_event);
        return extractFileName(sc_event.getFolderOldRelativePath());
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventOldFolderPath extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_old_folder_path";
        this.help_text = "File events: Gives the moved file's old parent folder's path. Folder events: Gives the renamed/moved folder's old path. The path is either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.";
        this.supported_sc_events = [
            SC_Event_FileMoved,
            SC_Event_FolderMoved,
            SC_Event_FolderRenamed,
        ];
    }
    async generateValue(castedArguments, sc_event) {
        this.requireCorrectEvent(sc_event);
        const folder_old_relative_path = sc_event.getFolderOldRelativePath();
        switch (castedArguments.mode.toLowerCase()) {
            case "relative":
                return normalizePath2(folder_old_relative_path);
            case "absolute":
                return normalizePath2(getVaultAbsolutePath(this.app) + "/" + folder_old_relative_path);
        }
        this.throw("Unrecognized mode parameter: " + castedArguments.mode);
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":absolute}}",
                help_text: "File events: Gives the moved file's old parent folder's path. Folder events: Gives the renamed/moved folder's old path. The path is absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":relative}}",
                help_text: "File events: Gives the moved file's old parent folder's path. Folder events: Gives the renamed/moved folder's old path. The path is relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":absolute}}",
                help_text: "File events: Gives the moved file's old parent folder's path. Folder events: Gives the renamed/moved folder's old path. The path is absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":relative}}",
                help_text: "File events: Gives the moved file's old parent folder's path. Folder events: Gives the renamed/moved folder's old path. The path is relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{event_file_path:relative}}</strong> or <strong>{{event_file_path:absolute}}</strong>";
    }
}
Variable_EventOldFolderPath.parameters = {
    mode: {
        options: ["absolute", "relative"],
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventOldTitle extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_old_title";
        this.help_text = "Gives the renamed file's old name without a file extension. If you need it with the extension, use {{event_old_file_name}} instead.";
        this.supported_sc_events = [
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(argumentsAreNotUsed, sc_event) {
        this.requireCorrectEvent(sc_event);
        return extractFileName(sc_event.getFileOldRelativePath(), false);
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_NewNoteFolderName extends Variable {
    constructor() {
        super(...arguments);
        this.variable_name = "new_note_folder_name";
        this.help_text = "Gives the folder name for \"Default location for new notes\" (a setting in Obsidian). No ancestor folders are included.";
    }
    async generateValue() {
        const current_file = this.app.workspace.getActiveFile(); // Needed just in case new notes should be created in the same folder as the currently open file.
        const folder = this.app.fileManager.getNewFileParent(current_file ? current_file.path : ""); // If no file is open, use an empty string as instructed in .getNewFileParent()'s documentation.
        if (!folder) {
            this.throw("Cannot determine a folder name for new notes. Please create a discussion in GitHub."); // I guess this never happens.
        }
        // If the folder is the vault's root folder, return "." instead of " " (a space character). I don't know why the name is " " when the folder is root.
        return folder.isRoot()
            ? "."
            : folder.name;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_NewNoteFolderPath extends Variable {
    constructor() {
        super(...arguments);
        this.variable_name = "new_note_folder_path";
        this.help_text = "Gives path to the \"Default location for new notes\" folder (a setting in Obsidian), either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.";
    }
    async generateValue(castedArguments) {
        const current_file = this.app.workspace.getActiveFile(); // Needed just in case new notes should be created in the same folder as the currently open file.
        const folder = this.app.fileManager.getNewFileParent(current_file ? current_file.path : ""); // If no file is open, use an empty string as instructed in .getNewFileParent()'s documentation.
        if (folder) {
            return getFolderPath(this.app, folder, castedArguments.mode);
        }
        else {
            this.throw("Cannot determine a folder path for new notes. Please create a discussion in GitHub."); // I guess this never happens.
        }
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":absolute}}",
                help_text: "Gives path to the \"Default location for new notes\" folder (a setting in Obsidian), absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":relative}}",
                help_text: "Gives path to the \"Default location for new notes\" folder (a setting in Obsidian), relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":absolute}}",
                help_text: "Gives path to the \"Default location for new notes\" folder (a setting in Obsidian), absolute from the root of the file system. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":relative}}",
                help_text: "Gives path to the \"Default location for new notes\" folder (a setting in Obsidian), relative from the root of the Obsidian vault. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{folder_path:relative}}</strong> or <strong>{{folder_path:absolute}}</strong>";
    }
}
Variable_NewNoteFolderPath.parameters = {
    mode: {
        options: ["absolute", "relative"],
        required: true,
    }
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_FileURI extends FileVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "file_uri";
        this.help_text = "Gives an Obsidian URI that opens the current file.";
    }
    async generateValue() {
        return this.plugin.getObsidianURI("open", {
            file: obsidian.normalizePath(this.getFileOrThrow().path), // Use normalizePath() instead of normalizePath2() because / should not be converted to \ on Windows because this is used as a URI, not as a file system path.
        });
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventFileURI extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_file_uri";
        this.help_text = "Gives an Obsidian URI that opens the event related file.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(argumentsAreNotUsed, sc_event) {
        this.requireCorrectEvent(sc_event);
        const file = sc_event.getFile();
        return this.plugin.getObsidianURI("open", {
            file: obsidian.normalizePath(file.path), // Use normalizePath() instead of normalizePath2() because / should not be converted to \ on Windows because this is used as a URI, not as a file system path.
        });
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_NoteContent extends FileVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "note_content";
        this.help_text = "Gives the current note's content without YAML frontmatter. If you need YAML included, use {{file_content}} instead.";
    }
    async generateValue() {
        return await getFileContentWithoutYAML(this.app, this.getFileOrThrow());
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventNoteContent extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_note_content";
        this.help_text = "Gives the event related file's content without YAML frontmatter. If you need YAML included, use {{event_file_content}} instead.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(argumentsAreNotUsed, sc_event) {
        this.requireCorrectEvent(sc_event);
        return await getFileContentWithoutYAML(this.app, sc_event.getFile());
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_FileContent extends FileVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "file_content";
        this.help_text = "Gives the current file's content, including YAML frontmatter. If you need YAML excluded, use {{note_content}} instead.";
    }
    async generateValue() {
        // Retrieve file content.
        return await app.vault.read(this.getFileOrThrow());
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventFileContent extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_file_content";
        this.help_text = "Gives the event related file's content, including YAML frontmatter. If you need YAML excluded, use {{event_note_content}} instead.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    async generateValue(argumentsAreNotUsed, sc_event) {
        this.requireCorrectEvent(sc_event);
        // Retrieve file content.
        return await app.vault.read(sc_event.getFile());
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_CaretParagraph extends EditorVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "caret_paragraph";
        this.help_text = "Gives a text line at the current caret position.";
    }
    async generateValue() {
        const editor = this.getEditorOrThrow();
        this.requireViewModeSource();
        const caretPosition = editor.getCursor('to');
        return editor.getLine(caretPosition.line);
    }
    getAvailabilityText() {
        return super.getAvailabilityText() + " Not available in preview mode.";
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_Newline extends Variable {
    constructor() {
        super(...arguments);
        this.variable_name = "newline";
        this.help_text = "Gives a \\n character. Used for testing line break escaping. An optional argument can be used to tell how many newlines are needed.";
    }
    async generateValue(castedArguments) {
        // Return \n, possibly repeating it
        return "\n".repeat(castedArguments.count ?? 1);
    }
    getAvailabilityText() {
        return "<strong>Only available</strong> in debug mode.";
    }
}
Variable_Newline.parameters = {
    count: {
        type: "integer",
        required: false,
    }
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_YAMLContent extends FileVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "yaml_content";
        this.help_text = "Gives the current note's YAML frontmatter. Dashes --- can be included or excluded.";
    }
    generateValue(castedArguments) {
        return new Promise((resolve, reject) => {
            let file;
            try {
                file = this.getFileOrThrow();
            }
            catch (error) {
                // Need to catch here, because Variable.getValue()'s .catch() block won't be able to catch thrown errors,
                // it can only catch errors that were passed to reject().
                reject(error);
                return;
            }
            getFileYAML(this.app, file, "with-dashes" === castedArguments.withDashes).then((yamlContent) => {
                if (null === yamlContent) {
                    // No YAML frontmatter.
                    this.reject("The current file does not contain a YAML frontmatter.", reject);
                }
                else {
                    // Got a YAML frontmatter.
                    resolve(yamlContent);
                }
            });
        });
    }
    getAvailabilityText() {
        return super.getAvailabilityText() + " Also, a YAML frontmatter section needs to be present.";
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":with-dashes}}",
                help_text: "Gives the current note's YAML frontmatter, wrapped between --- lines. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":no-dashes}}",
                help_text: "Gives the current note's YAML frontmatter, excluding top and bottom --- lines. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":with-dashes}}",
                help_text: "Gives the current note's YAML frontmatter, wrapped between --- lines." + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":no-dashes}}",
                help_text: "Gives the current note's YAML frontmatter, excluding top and bottom --- lines. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{yaml_content:with-dashes}}</strong> or <strong>{{yaml_content:no-dashes}}</strong>";
    }
}
Variable_YAMLContent.parameters = {
    withDashes: {
        options: ["with-dashes", "no-dashes"],
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Variable_EventYAMLContent extends EventVariable {
    constructor() {
        super(...arguments);
        this.variable_name = "event_yaml_content";
        this.help_text = "Gives the event related note's YAML frontmatter. Dashes --- can be included or excluded.";
        this.supported_sc_events = [
            SC_Event_FileMenu,
            SC_Event_FileCreated,
            SC_Event_FileContentModified,
            SC_Event_FileDeleted,
            SC_Event_FileMoved,
            SC_Event_FileRenamed,
        ];
    }
    generateValue(castedArguments, sc_event) {
        return new Promise((resolve, reject) => {
            try {
                this.requireCorrectEvent(sc_event);
            }
            catch (error) {
                // Need to catch here, because Variable.getValue()'s .catch() block won't be able to catch thrown errors,
                // it can only catch errors that were passed to reject().
                reject(error);
                return;
            }
            getFileYAML(this.app, sc_event.getFile(), castedArguments.withDashes === "with-dashes").then((yamlContent) => {
                if (null === yamlContent) {
                    // No YAML frontmatter.
                    this.reject("The event related file does not contain a YAML frontmatter.", reject);
                }
                else {
                    // Got a YAML frontmatter.
                    resolve(yamlContent);
                }
            });
        });
    }
    getAvailabilityText() {
        return super.getAvailabilityText() + " Also, a YAML frontmatter section needs to be present.";
    }
    getAutocompleteItems() {
        return [
            // Normal variables
            {
                value: "{{" + this.variable_name + ":with-dashes}}",
                help_text: "Gives the event related note's YAML frontmatter, wrapped between --- lines. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{" + this.variable_name + ":no-dashes}}",
                help_text: "Gives the event related note's YAML frontmatter, excluding top and bottom --- lines. " + this.getAvailabilityText(),
                group: "Variables",
                type: "normal-variable",
                documentationLink: this.getDocumentationLink(),
            },
            // Unescaped variables
            {
                value: "{{!" + this.variable_name + ":with-dashes}}",
                help_text: "Gives the event related note's YAML frontmatter, wrapped between --- lines." + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
            {
                value: "{{!" + this.variable_name + ":no-dashes}}",
                help_text: "Gives the event related note's YAML frontmatter, excluding top and bottom --- lines. " + this.getAvailabilityText(),
                group: "Variables",
                type: "unescaped-variable",
                documentationLink: this.getDocumentationLink(),
            },
        ];
    }
    getHelpName() {
        return "<strong>{{event_yaml_content:with-dashes}}</strong> or <strong>{{event_yaml_content:no-dashes}}</strong>";
    }
}
Variable_EventYAMLContent.parameters = {
    withDashes: {
        options: ["with-dashes", "no-dashes"],
        required: true,
    },
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function loadVariables(plugin) {
    const variables = new VariableSet([]);
    // Load CustomVariables
    // Do this before loading built-in variables so that these user-defined variables will appear first in all lists containing variables.
    plugin.getCustomVariableInstances().forEach((custom_variable_instance) => {
        variables.add(custom_variable_instance.createCustomVariable());
    });
    // Load built-in variables.
    const built_in_variables = [
        // Normal variables
        new Variable_CaretParagraph(plugin),
        new Variable_CaretPosition(plugin),
        new Variable_Clipboard(plugin),
        new Variable_Date(plugin),
        new Variable_Environment(plugin),
        new Variable_FileContent(plugin),
        new Variable_FileExtension(plugin),
        new Variable_FileName(plugin),
        new Variable_FilePath(plugin),
        new Variable_FileURI(plugin),
        new Variable_FolderName(plugin),
        new Variable_FolderPath(plugin),
        new Variable_NewNoteFolderName(plugin),
        new Variable_NewNoteFolderPath(plugin),
        new Variable_NoteContent(plugin),
        // Variable_Output is not loaded here, because it's only used in OutputWrappers.
        new Variable_Selection(plugin),
        new Variable_Tags(plugin),
        new Variable_Title(plugin),
        new Variable_VaultPath(plugin),
        new Variable_Workspace(plugin),
        new Variable_YAMLContent(plugin),
        new Variable_YAMLValue(plugin),
        // Event variables
        new Variable_EventFileContent(plugin),
        new Variable_EventFileExtension(plugin),
        new Variable_EventFileName(plugin),
        new Variable_EventFilePath(plugin),
        new Variable_EventFileURI(plugin),
        new Variable_EventFolderName(plugin),
        new Variable_EventFolderPath(plugin),
        new Variable_EventNoteContent(plugin),
        new Variable_EventOldFileName(plugin),
        new Variable_EventOldFilePath(plugin),
        new Variable_EventOldFolderName(plugin),
        new Variable_EventOldFolderPath(plugin),
        new Variable_EventOldTitle(plugin),
        new Variable_EventTags(plugin),
        new Variable_EventTitle(plugin),
        new Variable_EventYAMLContent(plugin),
        new Variable_EventYAMLValue(plugin),
    ];
    if (DEBUG_ON) {
        // Variables that are only designed for 'Shell commands test suite'.
        built_in_variables.push(new Variable_Newline(plugin), new Variable_Passthrough(plugin));
    }
    for (const built_in_variable of built_in_variables) {
        // JavaScript's Set does not have a method to add multiple items at once, so need to iterate them and add one-by-one.
        variables.add(built_in_variable);
    }
    return variables;
}
class VariableSet extends Set {
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * @param plugin
 * @param content
 * @param shell Used to determine how to escape special characters in variable values. Can be null, if no escaping is wanted.
 * @param t_shell_command Will only be used to read default value configurations. Can be null if no TShellCommand is available, but then no default values can be accessed.
 * @param sc_event Use undefined, if parsing is not happening during an event.
 * @param variables If you want to parse only a certain set of variables, define them in this parameter. If this is omitted, all variables will be parsed.
 * @param raw_value_augmenter A callback that will be called before every substitution. Allows modifying or completely changing the resulted variable values.
 * @param escaped_value_augmenter Same as raw_value_augmenter, but called after escaping the value. Can be used to for example wrap values in html elements for displaying purposes.
 * @return ParsingResult
 */
async function parseVariables(plugin, content, shell, t_shell_command, sc_event, variables = plugin.getVariables(), raw_value_augmenter = null, escaped_value_augmenter = null) {
    debugLog("parseVariables(): Starting to parse " + content + " with " + variables.size + " variables.");
    // Initialize a parsing result object
    const parsing_result = {
        original_content: content,
        parsed_content: content,
        succeeded: false,
        error_messages: [],
        count_parsed_variables: 0,
    };
    for (const variable of variables) {
        const pattern = new RegExp(variable.getPattern(), "igu"); // i: case-insensitive; g: match all occurrences instead of just the first one. u: support 4-byte unicode characters too.
        const parameter_names = variable.getParameterNames();
        let argument_matches;
        while ((argument_matches = pattern.exec(content)) !== null) {
            // Count how many times any variables have appeared.
            parsing_result.count_parsed_variables++;
            // Remove stuff that should not be iterated in a later loop.
            /** Need to prefix with _ because JavaScript reserves the variable name 'arguments'. */
            const _arguments = argument_matches.filter((value /* Won't be used */, key) => {
                return "number" === typeof key;
                // This leaves out for example the following non-numeric keys (and their values):
                // - "groups"
                // - "index"
                // - "input"
                // In the future, there can also come more elements that will be skipped. E.g. "indices". See: https://github.com/nothingislost/obsidian-dynamic-highlights/issues/25#issuecomment-1038563990 (referenced 2022-02-22).
            });
            // Get the {{variable}} string that will be substituted (= replaced with the actual value of the variable).
            const substitute = _arguments.shift(); // '_arguments[0]' contains the whole match, not just an argument. Get it and remove it from '_arguments'. 'as string' is used to tell TypeScript that _arguments[0] is always defined.
            // Iterate all arguments
            const presentArguments = {};
            for (const i in _arguments) {
                // Check that the argument is not omitted. It can be omitted (= undefined), if the parameter is optional.
                if (undefined !== _arguments[i]) {
                    // The argument is present.
                    const argument = _arguments[i].slice(1); // .slice(1): Remove a preceding :
                    const parameter_name = parameter_names[i];
                    presentArguments[parameter_name] = argument;
                }
            }
            // Should the variable's value be escaped? (Usually yes).
            let escape = true;
            if ("{{!" === substitute.slice(0, 3)) { // .slice(0, 3) = get characters 0...2, so stop before 3. The 'end' parameter is confusing.
                // The variable usage begins with {{! instead of {{
                // This means the variable's value should NOT be escaped.
                escape = false;
            }
            if (!shell) {
                // Escaping is forced OFF.
                escape = false;
            }
            // Render the variable
            const variable_value_result = await variable.getValue(t_shell_command, sc_event, presentArguments, 
            // Define a recursive callback that can be used to parse possible variables in a default value of the current variable.
            (raw_default_value) => {
                // Avoid circular references by removing the current variable from the set of parseable variables.
                // This will cumulate in deep nested parsing: Possible deeper parsing rounds will always have narrower
                // and narrower sets of variables to parse.
                const reduced_variables = removeFromSet(variables, variable);
                return parseVariables(plugin, raw_default_value, null, // Disable escaping special characters at this phase to avoid double escaping, as escaping will be done later.
                t_shell_command, sc_event, reduced_variables, raw_value_augmenter, escaped_value_augmenter);
            });
            // Allow custom modification of the raw value.
            if (raw_value_augmenter) {
                // The augmenter can modify the content of the variable_value_result object.
                raw_value_augmenter(variable, variable_value_result);
            }
            const raw_variable_value = variable_value_result.value;
            // Check possible error messages that might have come from rendering.
            if (variable_value_result.succeeded) {
                // Parsing was ok.
                // Escape the value if needed.
                let use_variable_value;
                if (escape) {
                    // Use an escaped value.
                    use_variable_value = escapeValue(shell, // shell is always a string when escape is true.
                    raw_variable_value);
                }
                else {
                    // No escaping is wanted, so use the raw value.
                    use_variable_value = raw_variable_value; // raw_variable_value is always a string when variable_value_result.succeeded is true.
                }
                // Augment the escaped value, if wanted.
                if (escaped_value_augmenter) {
                    use_variable_value = escaped_value_augmenter(variable, use_variable_value);
                }
                // Replace the variable name with the variable value.
                parsing_result.parsed_content = parsing_result.parsed_content /* not null */.replace(substitute, () => {
                    // Do the replacing in a function in order to avoid a possible $ character to be interpreted by JavaScript to interact with the regex.
                    // More information: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter (referenced 2021-11-02.)
                    return use_variable_value;
                });
            }
            else {
                // There has been problem(s) with this variable.
                debugLog("parseVariables(): Parsing content " + content + " failed.");
                parsing_result.succeeded = false;
                parsing_result.parsed_content = null;
                parsing_result.error_messages = variable_value_result.error_messages; // Returning now prevents parsing rest of the variables.
                return parsing_result;
            }
        }
    }
    debugLog("parseVariables(): Parsing content " + content + " succeeded.");
    parsing_result.succeeded = true;
    return parsing_result;
}
/**
 * Reads all variables from the content string, and returns a VariableSet containing all the found variables.
 *
 * This is needed in situations where variables will not be parsed (= variable values are not needed), but where it's just
 * needed to know what variables e.g. a shell command relies on.
 *
 * @param plugin
 * @param content
 */
function getUsedVariables(plugin, content) {
    const search_for_variables = plugin.getVariables();
    const found_variables = new VariableSet();
    for (const variable of search_for_variables) {
        const pattern = new RegExp(variable.getPattern(), "igu"); // i: case-insensitive; g: match all occurrences instead of just the first one. u: support 4-byte unicode characters too.
        if (pattern.exec(content) !== null) {
            // This variable was found.
            found_variables.add(variable);
        }
    }
    return found_variables;
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputChannel {
    /**
     * @param plugin
     * @param t_shell_command
     * @param shell_command_parsing_result
     * @param outputHandlingMode
     * @param processTerminator Will be called if user decides to end the process. Set to null if the process has already ended.
     */
    constructor(plugin, t_shell_command, shell_command_parsing_result, outputHandlingMode, processTerminator) {
        this.plugin = plugin;
        this.t_shell_command = t_shell_command;
        this.shell_command_parsing_result = shell_command_parsing_result;
        this.outputHandlingMode = outputHandlingMode;
        this.processTerminator = processTerminator;
        this.app = plugin.app;
        this.initialize();
    }
    /**
     * Can be overridden in child classes in order to vary the title depending on output_stream.
     * @param output_stream
     */
    static getTitle(output_stream) {
        return this.title;
    }
    /**
     * Sub classes can do here initializations that are common to both handleBuffered() and handleRealtime().
     *
     * Inits could be done in contructor(), too, but this is cleaner - no need to deal with parameters and no need for a super()
     * call.
     *
     * @protected
     */
    initialize() {
        // Do nothing by default.
    }
    async handleBuffered(output, error_code, enableOutputWrapping = true) {
        this.requireHandlingMode("buffered");
        // Qualify output
        if (OutputChannel.isOutputEmpty(output)) {
            // The output is empty
            if (!this.static().accepts_empty_output) {
                // This OutputChannel does not accept empty output, i.e. empty output should be just ignored.
                debugLog(this.constructor.name + ".handleBuffered(): Ignoring empty output.");
                return;
            }
        }
        debugLog(this.constructor.name + ".handleBuffered(): Handling output...");
        // Output is ok.
        // Handle it.
        await this._handleBuffered(await this.prepare_output(output, enableOutputWrapping), error_code);
        debugLog("Output handling is done.");
    }
    /**
     * @param outputStreamName
     * @param outputContent
     * @param enableOutputWrapping No caller actually sets this to false at the moment, unlike the handleBuffered() method's counterpart. But have this just in case.
     */
    async handleRealtime(outputStreamName, outputContent, enableOutputWrapping = true) {
        this.requireHandlingMode("realtime");
        // Qualify output
        if ("" === outputContent) {
            // The output is empty
            if (!this.static().accepts_empty_output) {
                // This OutputChannel does not accept empty output, i.e. empty output should be just ignored.
                debugLog(this.constructor.name + ".handleRealtime(): Ignoring empty output.");
                return;
            }
        }
        debugLog(this.constructor.name + ".handleRealtime(): Handling output...");
        // Output is ok.
        // If allowed, wrap the output with output wrapper text.
        if (enableOutputWrapping) {
            // Wrap output (but only if a wrapper is defined)
            outputContent = await this.wrapOutput(outputStreamName, outputContent);
        }
        // Handle it.
        await this._handleRealtime(outputContent, outputStreamName);
        debugLog("Output handling is done.");
    }
    _endRealtime(exitCode) {
        // Do nothing by default.
    }
    /**
     * When a shell command is executed in "realtime" mode, a separate ending call should be made in order to pass an
     * exit code to the OutputChannel. Some OutputChannels display the code to user, but most do not.
     *
     * @param exitCode
     */
    endRealtime(exitCode) {
        this.requireHandlingMode("realtime");
        this._endRealtime(exitCode);
    }
    requireHandlingMode(requiredMode) {
        if (this.outputHandlingMode !== requiredMode) {
            throw new Error("this.outputHandlingMode must be '" + requiredMode + "'.");
        }
    }
    static acceptsOutputStream(output_stream) {
        return this.accepted_output_streams.contains(output_stream);
    }
    /**
     * Does the following preparations:
     *  - Combines output streams (if wanted by the OutputChannel).
     *  - Wraps output (if defined in shell command configuration).
     * @param output_streams
     * @param enableOutputWrapping
     * @private
     */
    async prepare_output(output_streams, enableOutputWrapping) {
        const wrapOutputIfEnabled = async (outputStreamName, outputContent) => {
            if (enableOutputWrapping) {
                // Wrap output content.
                return await this.wrapOutput(outputStreamName, outputContent);
            }
            else {
                // Wrapping is disabled, return unmodified output content.
                return outputContent;
            }
        };
        const wrap_outputs_separately = async () => {
            const wrapped_output_streams = {};
            let output_stream_name;
            for (output_stream_name in output_streams) {
                wrapped_output_streams[output_stream_name] = await wrapOutputIfEnabled(output_stream_name, output_streams[output_stream_name]);
            }
            return wrapped_output_streams;
        };
        // Check if outputs should be combined.
        const combineOutputStreams = this.static().combine_output_streams;
        if (combineOutputStreams) {
            // Combine output strings into a single string.
            // Can output wrapping be combined?
            if (this.t_shell_command.isOutputWrapperStdoutSameAsStderr()) {
                // Output wrapping can be combined.
                return await wrapOutputIfEnabled("stdout", joinObjectProperties(output_streams, combineOutputStreams));
            }
            else {
                // Output wrapping needs to be done separately.
                const wrapped_output_streams = await wrap_outputs_separately();
                return joinObjectProperties(wrapped_output_streams, combineOutputStreams); // Use combineOutputStreams as a glue string.
            }
        }
        else {
            // Do not combine, handle each stream separately
            return await wrap_outputs_separately();
        }
    }
    /**
     * Surrounds the given output text with an output wrapper. If no output wrapper is defined, returns the original
     * output text without any modifications.
     */
    async wrapOutput(output_stream, output_content) {
        // Get preparsed output wrapper content. It has all other variables parsed, except {{output}}.
        const parsing_result_key = "output_wrapper_" + output_stream;
        const output_wrapper_content = this.shell_command_parsing_result[parsing_result_key];
        // Check if output wrapper content exists.
        if (undefined === output_wrapper_content) {
            // No OutputWrapper is defined for this shell command.
            // Return the output text without modifications.
            debugLog("Output wrapping: No wrapper is defined for '" + output_stream + "'.");
            return output_content;
        }
        // Parse the {{output}} variable
        const output_variable = new Variable_Output(this.plugin, output_content);
        const parsing_result = await parseVariables(this.plugin, output_wrapper_content, null, // No shell anymore, so no need for escaping.
        this.t_shell_command, null, // No support for {{event_*}} variables is needed, because they are already parsed in output_wrapper_content. This phase only parses {{output}} variable, nothing else.
        new VariableSet([output_variable]));
        // Inspect the parsing result. It should always succeed, as the {{output}} variable should not give any errors.
        if (parsing_result.succeeded) {
            // Succeeded.
            debugLog("Output wrapping: Wrapping " + output_stream + " succeeded.");
            return parsing_result.parsed_content;
        }
        else {
            // Failed for some reason.
            this.plugin.newError("Output wrapping failed, see error(s) below.");
            this.plugin.newErrors(parsing_result.error_messages);
            throw new Error("Output wrapping failed: Parsing {{output}} resulted in error(s): " + parsing_result.error_messages.join(" "));
        }
    }
    /**
     * Can be moved to a global function isOutputStreamEmpty() if needed.
     * @param output
     * @private
     */
    static isOutputEmpty(output) {
        if (undefined !== output.stderr) {
            return false;
        }
        return undefined === output.stdout || "" === output.stdout;
    }
    static() {
        return this.constructor;
    }
}
OutputChannel.accepted_output_streams = ["stdout", "stderr"];
OutputChannel.accepts_empty_output = false;
/**
 * Determines if the output channel wants to handle a unified output or not. If yes, this property should define a
 * delimiter string that will be used as a glue between different output streams.
 *
 * @protected
 */
OutputChannel.combine_output_streams = false;
/**
 * Used in OutputModal to redirect output based on hotkeys. If this is undefined, then the output channel is completely
 * excluded from OutputModal.
 */
OutputChannel.hotkey_letter = undefined;

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputChannel_Notification extends OutputChannel {
    constructor() {
        super(...arguments);
        /**
         * All received output cumulatively. Subsequent handlings will then use the whole output, not just new parts.
         * Only used in "realtime" mode.
         *
         * @private
         */
        this.realtimeContentBuffer = "";
        /**
         * A flag for indicating that if any stderr output has happened, all subsequent handlings should format the output
         * Notice message with error formatting (i.e. show [...] at the beginning of the message).
         * @private
         */
        this.realtimeHasStderrOccurred = false;
    }
    static getTitle(output_stream) {
        switch (output_stream) {
            case "stdout":
                return "Notification balloon";
            case "stderr":
                return "Error balloon";
        }
    }
    async _handleBuffered(output, error_code) {
        // Iterate output streams.
        // There can be both "stdout" and "stderr" present at the same time, or just one of them. If both are present, two
        // notifications will be created.
        let output_stream_name;
        for (output_stream_name in output) {
            const output_message = output[output_stream_name]; // as string = output message is not undefined because of the for loop.
            this.notify(output_stream_name, output_message, error_code);
        }
    }
    async _handleRealtime(outputContent, outputStreamName) {
        // Append new content
        this.realtimeContentBuffer += outputContent;
        // Raise a flag if seeing 'stderr' output.
        if ("stderr" === outputStreamName) {
            this.realtimeHasStderrOccurred = true;
        }
        // Does a Notice exist already?
        if (this.realtimeNotice) {
            // Reuse an existing Notice.
            // Should output be formatted as an error message?
            let updatedMessage;
            if (this.realtimeHasStderrOccurred) {
                // Apply error formatting to output
                updatedMessage = OutputChannel_Notification.formatErrorMessage(this.realtimeContentBuffer, null);
            }
            else {
                // Use output as-is
                updatedMessage = this.realtimeContentBuffer;
            }
            // Use the updated output
            this.realtimeNotice.setMessage(updatedMessage);
            // Update notice hiding timeout
            window.clearTimeout(this.realtimeNoticeTimeout); // Remove old timeout
            this.handleNotificationHiding(outputStreamName); // Add new timeout
        }
        else {
            // Create a new Notice.
            this.realtimeNotice = this.notify(this.realtimeHasStderrOccurred ? "stderr" : "stdout", this.realtimeContentBuffer, null, 0);
            // Create a timeout for hiding the Notice
            this.handleNotificationHiding(outputStreamName);
        }
        // Terminating button
        // @ts-ignore Notice.noticeEl belongs to Obsidian's PRIVATE API, and it may change without a prior notice. Only
        // create the button if noticeEl exists and is an HTMLElement.
        const noticeEl = this.realtimeNotice.noticeEl;
        if (null === this.processTerminator) {
            throw new Error("Process terminator is not set, although it should be set when handling output in realtime mode.");
        }
        if (undefined !== noticeEl && noticeEl instanceof HTMLElement) {
            this.plugin.createRequestTerminatingButton(noticeEl, this.processTerminator);
        }
    }
    _endRealtime(exitCode) {
        if (exitCode !== 0 || this.realtimeHasStderrOccurred) {
            // If a Notice exists, update it with the exitCode
            this.realtimeNotice?.setMessage(OutputChannel_Notification.formatErrorMessage(this.realtimeContentBuffer, exitCode));
        }
        // Remove terminating button
        // @ts-ignore Notice.noticeEl belongs to Obsidian's PRIVATE API, and it may change without a prior notice. Only
        // create the button if noticeEl exists and is an HTMLElement.
        const noticeEl = this.realtimeNotice?.noticeEl;
        if (undefined !== noticeEl && noticeEl instanceof HTMLElement) {
            noticeEl.find(".SC-icon-terminate-process")?.remove(); // ? = Only try to remove if the button exists. It does not exist if .setMessage() was called above as it overwrites all content in the Notice.
        }
    }
    /**
     *
     * @param outputStreamName
     * @param outputContent
     * @param exitCode
     * @param noticeTimeout Allows overriding the notice/error timeout setting.
     * @private
     */
    notify(outputStreamName, outputContent, exitCode, noticeTimeout) {
        switch (outputStreamName) {
            case "stdout":
                // Normal output
                return this.plugin.newNotification(outputContent, noticeTimeout ?? undefined);
            case "stderr":
                // Error output
                return this.plugin.newError(OutputChannel_Notification.formatErrorMessage(outputContent, exitCode), noticeTimeout ?? undefined);
        }
    }
    static formatErrorMessage(outputContent, exitCode) {
        if (null === exitCode) {
            // If a "realtime" process is not finished, there is no exit code yet.
            // @ts-ignore Yea I know "..." is not a number nor null. :)
            exitCode = "...";
        }
        return "[" + exitCode + "]: " + outputContent;
    }
    handleNotificationHiding(outputStreamName) {
        // Hide by timeout
        let normalTimeout;
        switch (outputStreamName) {
            case "stdout":
                normalTimeout = this.plugin.getNotificationMessageDurationMs();
                break;
            case "stderr":
                normalTimeout = this.plugin.getErrorMessageDurationMs();
                break;
        }
        this.realtimeNoticeTimeout = window.setTimeout(() => {
            // Hide the Notice
            this.realtimeNotice?.hide(); // ? = Don't try to hide if a user has closed the notification by clicking. See the 'this.realtimeNotice = undefined;' line in the below click handler.
            this.realtimeNotice = undefined;
            this.realtimeNoticeTimeout = undefined;
        }, normalTimeout);
        // Subscribe to Notice's click event.
        // @ts-ignore Notice.noticeEl belongs to Obsidian's PRIVATE API, and it may change without a prior notice. Only
        // define the click listener if noticeEl exists and is an HTMLElement.
        const noticeEl = this.realtimeNotice.noticeEl;
        if (undefined !== noticeEl && noticeEl instanceof HTMLElement) {
            noticeEl.onClickEvent(() => {
                window.clearTimeout(this.realtimeNoticeTimeout); // Make sure timeout will not accidentally try to later hide an already hidden Notification.
                this.realtimeNoticeTimeout = undefined;
                this.realtimeNotice = undefined; // Give a signal to _handleRealtime() that if new output comes, a new Notice should be created.
            });
        }
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputChannel_CurrentFile extends OutputChannel {
    async _handleBuffered(outputContent) {
        this.handle(outputContent);
    }
    async _handleRealtime(outputContent) {
        this.handle(outputContent);
    }
    handle(output_message) {
        const editor = getEditor(this.app);
        const view = getView(this.app);
        if (null === editor) {
            // For some reason it's not possible to get an editor.
            this.plugin.newError("Could not get an editor instance! Please create a discussion in GitHub. The command output is in the next error box:");
            this.plugin.newError(output_message); // Good to output it at least some way.
            debugLog("OutputChannel_CurrentFile: Could not get an editor instance.");
            return;
        }
        // Check if the view is in source mode
        if (null === view) {
            // For some reason it's not possible to get an editor, but it's not a big problem.
            debugLog("OutputChannel_CurrentFile: Could not get a view instance.");
        }
        else {
            // We do have a view
            if ("source" !== view.getMode()) {
                // Warn that the output might go to an unexpected place in the note file.
                this.plugin.newNotification("Note that your active note is not in 'Edit' mode! The output comes visible when you switch to 'Edit' mode again!");
            }
        }
        // Insert into the current file
        this.insertIntoEditor(editor, output_message);
    }
}
/**
 * There can be both "stdout" and "stderr" present at the same time, or just one of them. If both are present, they
 * will be joined together with " " as a separator.
 * @protected
 */
OutputChannel_CurrentFile.combine_output_streams = " ";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputChannel_CurrentFileCaret extends OutputChannel_CurrentFile {
    /**
     * Inserts text into the given editor, at caret position.
     *
     * @param editor
     * @param output_message
     * @protected
     */
    insertIntoEditor(editor, output_message) {
        editor.replaceSelection(output_message);
    }
}
OutputChannel_CurrentFileCaret.title = "Current file: caret position";
OutputChannel_CurrentFileCaret.hotkey_letter = "R";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputChannel_CurrentFileTop extends OutputChannel_CurrentFile {
    /**
     * Inserts text into the given editor, at top.
     *
     * @param editor
     * @param output_message
     * @protected
     */
    insertIntoEditor(editor, output_message) {
        const top_position = editor.offsetToPos(0);
        editor.replaceRange(output_message, top_position);
    }
}
OutputChannel_CurrentFileTop.title = "Current file: top";
OutputChannel_CurrentFileTop.hotkey_letter = "T";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputChannel_StatusBar extends OutputChannel {
    constructor() {
        super(...arguments);
        /**
         * All received output cumulatively. Subsequent handlings will then use the whole output, not just new parts.
         * Only used in "realtime" mode.
         *
         * @private
         */
        this.realtimeContentBuffer = "";
    }
    async _handleBuffered(outputContent) {
        this.setStatusBarContent(outputContent);
    }
    async _handleRealtime(outputContent) {
        this.realtimeContentBuffer += outputContent;
        this.setStatusBarContent(this.realtimeContentBuffer);
    }
    setStatusBarContent(outputContent) {
        const status_bar_element = this.plugin.getOutputStatusBarElement();
        outputContent = outputContent.trim();
        // Full output (shown when hovering with mouse)
        status_bar_element.setAttr("aria-label", outputContent);
        // Show last line permanently.
        const output_message_lines = outputContent.split(/(\r\n|\r|\n)/u);
        const last_output_line = output_message_lines[output_message_lines.length - 1];
        status_bar_element.setText(last_output_line);
    }
}
OutputChannel_StatusBar.title = "Status bar";
OutputChannel_StatusBar.accepts_empty_output = true;
OutputChannel_StatusBar.hotkey_letter = "S";
/**
 * Combine stdout and stderr (in case both of them happen to be present).
 * @protected
 */
OutputChannel_StatusBar.combine_output_streams = os.EOL + os.EOL;

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputChannel_CurrentFileBottom extends OutputChannel_CurrentFile {
    /**
     * Inserts text into the given editor, at bottom.
     *
     * @param editor
     * @param output_message
     * @protected
     */
    insertIntoEditor(editor, output_message) {
        const bottom_position = {
            ch: editor.getLine(editor.lastLine()).length,
            line: editor.lastLine(), // ... the last line.
        }; // *) But do not subtract 1, because ch is zero-based, so when .length is used without -1, we are pointing AFTER the last character.
        editor.replaceRange(output_message, bottom_position);
    }
}
OutputChannel_CurrentFileBottom.title = "Current file: bottom";
OutputChannel_CurrentFileBottom.hotkey_letter = "B";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputChannel_Clipboard extends OutputChannel {
    constructor() {
        super(...arguments);
        /**
         * All received output cumulatively. Subsequent handlings will then use the whole output, not just new parts.
         * Only used in "realtime" mode.
         *
         * @private
         */
        this.realtimeContentBuffer = "";
    }
    async _handleBuffered(outputContent) {
        await copyToClipboard(outputContent);
        this.notify(outputContent);
    }
    async _handleRealtime(outputContent) {
        this.realtimeContentBuffer += outputContent;
        await copyToClipboard(this.realtimeContentBuffer);
        this.notify(this.realtimeContentBuffer);
    }
    notify(output_message) {
        if (this.plugin.settings.output_channel_clipboard_also_outputs_to_notification) {
            // Notify the user so they know a) what was copied to clipboard, and b) that their command has finished execution.
            this.plugin.newNotification("Copied to clipboard: " + os.EOL + output_message + os.EOL + os.EOL + "(Notification can be turned off in settings.)");
        }
    }
}
OutputChannel_Clipboard.title = "Clipboard";
OutputChannel_Clipboard.hotkey_letter = "L";
/**
 * There can be both "stdout" and "stderr" present at the same time, or just one of them. If both are present, they
 * will be joined together with " " as a separator.
 * @protected
 */
OutputChannel_Clipboard.combine_output_streams = " "; // TODO: Change to "" as there should be no extra space between stdout and stderr. Compare it to the terminal: AFAIK there is no separation between stdout and stderr outputs, just that typically each output ends with a newline.

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * TODO: Move this to TShellCommand.
 */
function getHotkeysForShellCommand(plugin, shell_command_id) {
    // Retrieve all hotkeys set by user.
    // @ts-ignore
    const app_custom_hotkeys = plugin.app.hotkeyManager?.customKeys;
    if (!app_custom_hotkeys) {
        debugLog("getHotkeysForShellCommand() failed, will return an empty array.");
        return [];
    }
    // Get only our hotkeys.
    const hotkey_index = plugin.getPluginId() + ":" + plugin.generateObsidianCommandId(shell_command_id); // E.g. "obsidian-shellcommands:shell-command-0"
    debugLog("getHotkeysForShellCommand() succeeded.");
    return app_custom_hotkeys[hotkey_index] ?? []; // If no hotkey array is set for this command, return an empty array. Although I do believe that all commands do have an array anyway, but have this check just in case.
}
/**
 * TODO: Is there a way to make Obsidian do this conversion for us? Check this: https://github.com/pjeby/hotkey-helper/blob/c8a032e4c52bd9ce08cb909cec15d1ed9d0a3439/src/plugin.js#L4-L6
 *
 * @param hotkey
 * @constructor
 */
function HotkeyToString(hotkey) {
    const keys = [];
    hotkey.modifiers.forEach((modifier) => {
        let modifier_key = modifier.toString(); // This is one of 'Mod' | 'Ctrl' | 'Meta' | 'Shift' | 'Alt'
        if ("Mod" === modifier_key) {
            // Change "Mod" to something more meaningful.
            modifier_key = CmdOrCtrl(); // isMacOS should also be true if the device is iPhone/iPad. Can be handy if this plugin gets mobile support some day.
        }
        keys.push(modifier_key);
    });
    keys.push(hotkey.key); // This is something like a letter ('A', 'B' etc) or space/enter/whatever.
    return keys.join(" + ");
}
function CmdOrCtrl() {
    return obsidian.Platform.isMacOS ? "Cmd" : "Ctrl";
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputChannel_Modal extends OutputChannel {
    initialize() {
        // Initialize a modal (but don't open yet)
        this.modal = new OutputModal(this.plugin, this.t_shell_command, this.shell_command_parsing_result, this.processTerminator);
    }
    async _handleBuffered(outputs, error_code) {
        // Pass outputs to modal
        this.modal.setOutputContents(outputs);
        // Define a possible error code to be shown on the modal.
        if (error_code !== null) {
            this.modal.setExitCode(error_code);
        }
        // Done
        this.modal.open();
    }
    async _handleRealtime(outputContent, outputStreamName) {
        this.modal.addOutputContent(outputStreamName, outputContent);
        if (!this.modal.isOpen()) {
            this.modal.open();
        }
    }
    /**
     * @param exitCode Can be null if user terminated the process by clicking a button. In other places exitCode can be null if process is still running, but here that cannot be the case.
     *
     * @protected
     */
    _endRealtime(exitCode) {
        // Delete terminator button as the process is already ended.
        this.modal.removeProcessTerminatorButton();
        // Pass exitCode to the modal
        this.modal.setExitCode(exitCode);
    }
}
OutputChannel_Modal.title = "Ask after execution";
class OutputModal extends SC_Modal {
    constructor(plugin, t_shell_command, shell_command_parsing_result, processTerminator) {
        super(plugin);
        this.processTerminator = processTerminator;
        this.exit_code = null; // TODO: Think about changing the logic: exit code could be undefined when it's not received, and null when a user has terminated the execution. The change needs to be done in the whole plugin, although I only wrote about it in this OutputModal class.
        this.outputFields = {};
        this.t_shell_command = t_shell_command;
        this.shell_command_parsing_result = shell_command_parsing_result;
        this.createOutputFields();
    }
    /**
     * Called when doing "buffered" output handling.
     *
     * @param outputs
     */
    setOutputContents(outputs) {
        Object.getOwnPropertyNames(outputs).forEach((outputStreamName) => {
            const outputField = this.outputFields[outputStreamName];
            // Set field value
            const textareaComponent = outputField.components.first();
            const outputContent = outputs[outputStreamName];
            textareaComponent.setValue(outputContent); // as string = outputContent is not undefined because of the .forEach() loop.
            // Make field visible (if it's not already)
            outputField.settingEl.matchParent(".SC-hide")?.removeClass("SC-hide");
        });
    }
    /**
     * Called when doing "realtime" output handling.
     *
     * @param outputStreamName
     * @param outputContent
     */
    addOutputContent(outputStreamName, outputContent) {
        const outputField = this.outputFields[outputStreamName];
        // Update field value
        const textareaComponent = outputField.components.first();
        textareaComponent.setValue(textareaComponent.getValue() + outputContent);
        // Make field visible (if it's not already)
        outputField.settingEl.matchParent(".SC-hide")?.removeClass("SC-hide");
    }
    onOpen() {
        super.onOpen();
        this.modalEl.addClass("SC-modal-output");
        // Heading
        const heading = this.shell_command_parsing_result.alias;
        this.titleEl.innerText = heading ? heading : "Shell command output"; // TODO: Use this.setTitle() instead.
        // Shell command preview
        this.modalEl.createEl("pre", { text: this.shell_command_parsing_result.shell_command, attr: { class: "SC-no-margin SC-wrappable" } }); // no margin so that exit code will be close.
        // Container for terminating button and exit code
        const processResultContainer = this.modalEl.createDiv();
        // 'Request to terminate the process' icon button
        if (this.processTerminator) {
            this.processTerminatorButtonContainer = processResultContainer.createEl('span');
            this.plugin.createRequestTerminatingButton(this.processTerminatorButtonContainer, this.processTerminator);
        }
        // Exit code (put on same line with process terminator button, if exists)
        this.exitCodeElement = processResultContainer.createEl("small", { text: "Executing...", attr: { style: "font-weight: bold;" } }); // Show "Executing..." before an actual exit code is received.
        if (this.exit_code !== null) {
            this.displayExitCode();
        }
        // Output fields
        this.modalEl.insertAdjacentElement("beforeend", this.outputFieldsContainer);
        // Focus on the first output field
        this.focusFirstField();
        // A tip about selecting text.
        this.modalEl.createDiv({
            text: "Tip! If you select something, only the selected text will be used.",
            attr: { class: "setting-item-description" /* A CSS class defined by Obsidian. */ },
        });
    }
    createOutputFields() {
        // Create a parent-less container. onOpen() will place it in the correct place.
        this.outputFieldsContainer = document.createElement('div');
        // Create field containers in correct order
        let stdoutFieldContainer;
        let stderrFieldContainer;
        switch (this.t_shell_command.getOutputChannelOrder()) {
            case "stdout-first": {
                stdoutFieldContainer = this.outputFieldsContainer.createDiv();
                stderrFieldContainer = this.outputFieldsContainer.createDiv();
                break;
            }
            case "stderr-first": {
                stderrFieldContainer = this.outputFieldsContainer.createDiv();
                stdoutFieldContainer = this.outputFieldsContainer.createDiv();
                break;
            }
        }
        // Create fields
        this.outputFields.stdout = this.createOutputField("stdout", stdoutFieldContainer);
        this.outputFields.stderr = this.createOutputField("stderr", stderrFieldContainer);
        // Hide the fields' containers at the beginning. They will be shown when content is added.
        stdoutFieldContainer.addClass("SC-hide");
        stderrFieldContainer.addClass("SC-hide");
    }
    createOutputField(output_stream, containerElement) {
        let output_textarea;
        containerElement.createEl("hr", { attr: { class: "SC-no-margin" } });
        // Output stream name
        new obsidian.Setting(containerElement)
            .setName(output_stream)
            .setHeading()
            .setClass("SC-no-bottom-border");
        // Textarea
        const textarea_setting = new obsidian.Setting(containerElement)
            .addTextArea(textarea => output_textarea = textarea);
        textarea_setting.infoEl.addClass("SC-hide"); // Make room for the textarea by hiding the left column.
        textarea_setting.settingEl.addClass("SC-output-channel-modal-textarea-container", "SC-no-top-border");
        // Add controls for redirecting the output to another channel.
        const redirect_setting = new obsidian.Setting(containerElement)
            .setDesc("Redirect:")
            .setClass("SC-no-top-border")
            .setClass("SC-output-channel-modal-redirection-buttons-container") // I think this calls actually HTMLDivElement.addClass(), so it should not override the previous .setClass().
        ;
        const outputChannels = getOutputChannelClasses();
        Object.getOwnPropertyNames(outputChannels).forEach((output_channel_name) => {
            const outputChannelClass = outputChannels[output_channel_name];
            // Ensure this channel is not excluded by checking that is has a hotkey defined.
            if (outputChannelClass.hotkey_letter) {
                // Ensure the output channel accepts this output stream. E.g. OutputChannel_OpenFiles does not accept "stderr".
                if (outputChannelClass.acceptsOutputStream(output_stream)) {
                    const textarea_element = textarea_setting.settingEl.find("textarea");
                    // Define an output handler
                    const handle_output = async () => {
                        // Redirect output to the selected channel
                        const output_streams = {};
                        output_streams[output_stream] =
                            getSelectionFromTextarea(textarea_element, true) // Use the selection, or...
                                ?? output_textarea.getValue() // ...use the whole text, if nothing is selected.
                        ;
                        const outputChannel = initializeOutputChannel(output_channel_name, this.plugin, this.t_shell_command, this.shell_command_parsing_result, "buffered", // Use "buffered" mode even if this modal was opened in "realtime" mode, because at this point the output redirection is a single-time job, not recurring.
                        this.processTerminator);
                        await outputChannel.handleBuffered(output_streams, this.exit_code, false); // false: Disable output wrapping as it's already wrapped before the output content was passed to this modal.
                    };
                    // Create the button
                    redirect_setting.addButton((button) => {
                        button.onClick(async (event) => {
                            // Handle output
                            await handle_output();
                            // Finish
                            if (event.ctrlKey) {
                                // Special click, control/command key is pressed.
                                // Close the modal.
                                this.close();
                            }
                            else {
                                // Normal click, control key is not pressed.
                                // Do not close the modal.
                                textarea_element.focus(); // Bring the focus back to the textarea in order to show a possible highlight (=selection) again.
                            }
                        });
                        // Define button texts and assign hotkeys
                        const output_channel_title = outputChannelClass.getTitle(output_stream);
                        // Button text
                        button.setButtonText(output_channel_title);
                        // Tips about hotkeys
                        button.setTooltip(`Redirect: Normal click OR ${CmdOrCtrl()} + ${outputChannelClass.hotkey_letter}.`
                            + os.EOL + os.EOL +
                            `Redirect and close the modal: ${CmdOrCtrl()} + click OR ${CmdOrCtrl()} + Shift + ${outputChannelClass.hotkey_letter}.`);
                    });
                    // 1. hotkey: Ctrl/Cmd + number: handle output
                    this.scope.register(["Ctrl"], outputChannelClass.hotkey_letter, handle_output);
                    // 2. hotkey: Ctrl/Cmd + Shift + number: handle output and close the modal.
                    this.scope.register(["Ctrl", "Shift"], outputChannelClass.hotkey_letter, () => {
                        handle_output().then(); // then(): No need to wait for output handling to finish before closing the modal.
                        this.close();
                    });
                }
            }
        });
        return textarea_setting;
    }
    removeProcessTerminatorButton() {
        if (this.processTerminatorButtonContainer) {
            this.processTerminatorButtonContainer.remove();
        }
    }
    /**
     * Should be called only if an exit code was received.
     *
     * @param exit_code Can be null if user terminated the process by clicking a button.
     */
    setExitCode(exit_code) {
        this.exit_code = exit_code;
        // Try to show the exit code.
        if (this.isOpen()) {
            if (null === this.exit_code) {
                // User has terminated the process, so there's no exit code even though the process has ended.
                this.exitCodeElement.innerText = "User terminated";
            }
            else {
                // displayExistCode() can only be called if onOpen() has been called before.
                // If onOpen() will be called later, it will call displayExitCode() itself when it sees that this.exit_code is defined.
                this.displayExitCode();
            }
        }
    }
    displayExitCode() {
        if (null === this.exit_code) {
            // Currently there are two callers for this method, and both of them does a null check on the exit code before'
            // the call, so we'll never get here in practise.
            // TODO: Remove this checking/throwing and make this method able to display three texts: a) an exit code, b) Executing..., or c) User terminated.
            throw new Error("Cannot display exit code because it's null");
        }
        this.exitCodeElement.innerText = "Exit code: " + this.exit_code.toString();
    }
    focusFirstField() {
        switch (this.t_shell_command.getOutputChannelOrder()) {
            case "stdout-first": {
                this.outputFields.stdout.controlEl.find("textarea").focus();
                break;
            }
            case "stderr-first": {
                this.outputFields.stderr.controlEl.find("textarea").focus();
                break;
            }
        }
    }
    approve() {
        // No need to perform any action, just close the modal.
        this.close();
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputChannel_OpenFiles extends OutputChannel {
    _handleBuffered(output, error_code) {
        let handlingPipeline = Promise.resolve();
        let output_stream_name;
        for (output_stream_name in output) {
            handlingPipeline = handlingPipeline.finally(() => {
                return this.handle(output[output_stream_name]);
            });
        }
        return handlingPipeline;
    }
    _handleRealtime(outputContent) {
        return this.handle(outputContent);
    }
    handle(outputContent) {
        return new Promise((resolve) => {
            // Read file definitions. Usually there's just one, but there can be many. Definitions are separated by newline
            // characters. Each file definition defines one file to be opened.
            const file_definitions_string = outputContent.trim(); // Contains at least file name(s), and MAYBE: a caret position, new pane option, and view state
            const file_definitions = file_definitions_string.split(/[\r\n]+/u);
            // Iterate all file definitions that should be opened.
            let opening_pipeline = Promise.resolve();
            for (const file_definition of file_definitions) {
                // Chain each file opening to happen one after another. If one file opening fails for whatever reason, it
                // is ok to continue to open the next file. This is why .finally() is used instead of .then().
                opening_pipeline = opening_pipeline.finally(() => {
                    return this.interpretFileOpeningDefinition(file_definition);
                });
            }
            opening_pipeline.finally(() => resolve() /* Tell that all openings have been processed. */);
        });
    }
    interpretFileOpeningDefinition(file_definition) {
        return new Promise((resolve, reject) => {
            debugLog("OutputChannel_OpenFiles: Interpreting file opening definition: " + file_definition);
            // Get parts that define different details about how the file should be opened
            const file_definition_parts = file_definition.split(":"); // If file_definition is "", i.e. an empty string, the result will be [""], i.e. an array with an empty string as its only item.
            // The first part is always the file path
            let open_file_path = file_definition_parts.shift(); // If file_definition is "", this will be "", too. 'as string' is used because file_definition_parts is never empty (it always contains at least one item), so .shift() will never return undefined here.
            // On Windows: Check if an absolute path was split incorrectly. (E.g. a path starting with "C:\...").
            if (isWindows() && file_definition_parts.length > 0) {
                const combined_path = open_file_path + ":" + file_definition_parts[0];
                if (path__namespace.isAbsolute(combined_path)) {
                    // Yes, the first two parts do form an absolute path together, so they should not be split.
                    open_file_path = combined_path;
                    file_definition_parts.shift(); // Remove the second part so that it won't be accidentally processed in the 'Special features' part.
                }
            }
            // Trim the file path, for being able to use cleaner separation between file name and other parts, e.g: MyFile.md : new-pane
            open_file_path = open_file_path.trim();
            // Special features
            const caret_parts = []; // If caret position is present in file_definition_parts, the first item in this array will be the caret line, the second will be the column. If more parts are present, they will be used for making selections.
            let newLeaf = false;
            let can_create_file = false;
            let file_definition_interpreting_failed = false;
            file_definition_parts.forEach((file_definition_part) => {
                file_definition_part = file_definition_part.toLocaleLowerCase().trim(); // .trim() is for being able to use cleaner separation between e.g. different selections: MyFile.md:1:1:1:-1 : 5:1:5:-1
                // Determine the part type
                if (isInteger(file_definition_part, true)) {
                    // This is a number, so consider it as a caret position part.
                    caret_parts.push(parseInt(file_definition_part));
                }
                else {
                    const multipleNewPartsErrorMessage = "Cannot open file: Only one of the following can be defined: new-pane, new-tab, or new-window.";
                    switch (file_definition_part) {
                        case "new-pane":
                            // Ensure no new-* definition is used before.
                            if (newLeaf === false) {
                                newLeaf = "split";
                            }
                            else {
                                this.plugin.newError(multipleNewPartsErrorMessage);
                                file_definition_interpreting_failed = true;
                            }
                            break;
                        case "new-tab":
                            // Ensure no new-* definition is used before.
                            if (newLeaf === false) {
                                newLeaf = "tab";
                            }
                            else {
                                this.plugin.newError(multipleNewPartsErrorMessage);
                                file_definition_interpreting_failed = true;
                            }
                            break;
                        case "new-window":
                            // Ensure no new-* definition is used before.
                            if (newLeaf === false) {
                                newLeaf = "window";
                            }
                            else {
                                this.plugin.newError(multipleNewPartsErrorMessage);
                                file_definition_interpreting_failed = true;
                            }
                            break;
                        case "can-create-file":
                            can_create_file = true;
                            break;
                        default:
                            this.plugin.newError("Cannot open file: Unrecognised definition part: " + file_definition_part + " in " + file_definition);
                            file_definition_interpreting_failed = true;
                    }
                }
            });
            if (file_definition_interpreting_failed) {
                reject();
                return;
            }
            // Ensure the path is relative
            if (path__namespace.isAbsolute(open_file_path)) {
                // The path is absolute.
                // Check if it can be converted to relative.
                const vault_absolute_path = getVaultAbsolutePath(this.app);
                if (open_file_path.toLocaleLowerCase().startsWith(vault_absolute_path.toLocaleLowerCase())) {
                    // Converting to relative is possible
                    open_file_path = open_file_path.substr(vault_absolute_path.length); // Get everything after the point where the vault path ends.
                }
                else {
                    // Cannot convert to relative, because the file does not reside in the vault
                    this.plugin.newError("Cannot open file '" + open_file_path + "' as the path is outside this vault.");
                    reject();
                    return;
                }
            }
            // Clean up the file path
            open_file_path = obsidian.normalizePath(open_file_path); // normalizePath() is used on purpose, instead of normalizePath2(), because backslashes \ should be converted to forward slashes /
            this.openFileInTab(open_file_path, newLeaf, can_create_file).then(() => {
                // The file is now open
                // Check, did we have a caret position available. If not, do nothing.
                const count_caret_parts = caret_parts.length;
                if (count_caret_parts > 0) {
                    // Yes, a caret position was defined in the output.
                    // Ensure the correct amount of caret position parts.
                    // 0 parts: no caret positioning needs to be done (but in this part of code the amount of parts is always greater than 0).
                    // 1 part: caret line is defined, no column.
                    // 2 parts: caret line and column are defined.
                    // 3 parts: NOT ALLOWED.
                    // 4 parts: selection starting position (line, column) and selection end position (line, column) are defined.
                    // 5 parts or more: NOT ALLOWED. Exception: any number of sets of four parts is allowed, i.e. 8 parts, 12 parts, 16 parts etc. are allowed as they can define multiple selections.
                    const error_message_base = "File opened, but caret cannot be positioned due to an incorrect amount (" + count_caret_parts + ") of numeric values in the output: " + file_definition + os.EOL + os.EOL;
                    if (count_caret_parts == 3) {
                        // Incorrect amount of caret parts
                        this.plugin.newError(error_message_base + "Three numeric parts is an incorrect amount, correct would be 1,2 or 4 parts.");
                        reject();
                        return;
                    }
                    else if (count_caret_parts > 4 && count_caret_parts % 4 !== 0) {
                        // Incorrect amount of caret parts
                        this.plugin.newError(error_message_base + "Perhaps too many numeric parts are defined? If more than four parts are defined, make sure to define complete sets of four parts. The amount of numeric parts needs to be dividable by 4.");
                        reject();
                        return;
                    }
                    // Even though the file is already loaded, rendering it may take some time, thus the height of the content may increase.
                    // For this reason, there needs to be a tiny delay before setting the caret position. If the caret position is set immediately,
                    // the caret will be placed in a correct position, but it might be that the editor does not scroll into correct position, so the
                    // caret might be out of the view, even when it's in a correct place. (Obsidian version 0.13.23).
                    window.setTimeout(() => {
                        const editor = getEditor(this.app);
                        if (editor) {
                            if (count_caret_parts >= 4) {
                                // Selection mode
                                // There can be multiple selections defined
                                const selections = [];
                                while (caret_parts.length) {
                                    const fromLine = caret_parts.shift();
                                    const fromColumn = caret_parts.shift();
                                    const toLine = caret_parts.shift();
                                    const toColumn = caret_parts.shift();
                                    if (undefined === fromLine || undefined === fromColumn || undefined === toLine || undefined === toColumn) {
                                        // This should never happen.
                                        throw new Error("Encountered undefined values in fromLine, fromColumn, toLine, and/or toColumn. Strange, because the correct amount of parts in caret_parts was checked beforehand.");
                                    }
                                    selections.push({
                                        anchor: prepareEditorPosition(editor, fromLine, fromColumn),
                                        head: prepareEditorPosition(editor, toLine, toColumn),
                                    });
                                }
                                editor.setSelections(selections);
                            }
                            else {
                                // Simple caret mode
                                const caret_line = caret_parts[0];
                                const caret_column = caret_parts[1] ?? 1;
                                editor.setCursor(prepareEditorPosition(editor, caret_line, caret_column));
                            }
                            // After placing carets / selecting text, have a small delay after allowing to open another file (in case multiple files are opened in a row). This allows the selection to be remembered in the pane's history.
                            window.setTimeout(resolve, 300); // If you change this ADDITIONAL delay, remember to change it in the documentation, too.
                        }
                        else {
                            // No editor
                            this.plugin.newError("File opened, but caret cannot be positioned because no editor was found.");
                            reject();
                        }
                    }, 500); // 500ms is probably long enough even if a new tab is opened (takes more time than opening a file into an existing tab). This can be made into a setting sometime. If you change this, remember to change it in the documentation, too.
                }
                else {
                    // No caret parts exist. All is done now.
                    resolve();
                }
            }, (error_message) => {
                if (typeof error_message === "string") {
                    // Opening the file has failed.
                    this.plugin.newError(error_message);
                }
                else {
                    // Some other runtime error has occurred.
                    throw error_message;
                }
                reject();
            });
        });
    }
    openFileInTab(file_path, newLeaf, can_create_file) {
        // Ensure that the file exists (or can be created)
        const source_path = ""; // TODO: When adding an option for creating new files, read this documentation from Obsidian API's getNewFileParent(): "sourcePath – The path to the current open/focused file, used when the user wants new files to be created “in the same folder”. Use an empty string if there is no active file."
        const file_exists_or_can_be_created = can_create_file || null !== this.app.metadataCache.getFirstLinkpathDest(file_path, source_path);
        if (file_exists_or_can_be_created) {
            // Yes, the file exists (or can be created)
            return this.app.workspace.openLinkText(file_path, source_path, newLeaf);
        }
        else {
            // No, the file does not exist, and it may not be created.
            return Promise.reject("Cannot open file '" + file_path + "', as it does not exist. (If you want to allow file creation, add :can-create-file to the shell command output.)");
        }
    }
}
OutputChannel_OpenFiles.title = "Open files";
OutputChannel_OpenFiles.hotkey_letter = "O";
/**
 * This output channel is not suitable for stderr, as stderr can contain unexpected messages.
 * @protected
 */
OutputChannel_OpenFiles.accepted_output_streams = ["stdout"];

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
const outputChannelClasses = {};
// Register output channels
registerOutputChannel("notification", OutputChannel_Notification);
registerOutputChannel("current-file-caret", OutputChannel_CurrentFileCaret);
registerOutputChannel("current-file-top", OutputChannel_CurrentFileTop);
registerOutputChannel("current-file-bottom", OutputChannel_CurrentFileBottom);
registerOutputChannel("open-files", OutputChannel_OpenFiles);
registerOutputChannel("status-bar", OutputChannel_StatusBar);
registerOutputChannel("clipboard", OutputChannel_Clipboard);
registerOutputChannel("modal", OutputChannel_Modal);
/**
 * This function is designed to be called after a 'Wait until finished' type of shell command finishes its execution.
 *
 * @param plugin
 * @param t_shell_command
 * @param shell_command_parsing_result
 * @param stdout
 * @param stderr
 * @param error_code TODO: Rename to exitCode everywhere in the codebase.
 * @param output_channels
 */
function handleBufferedOutput(plugin, t_shell_command, shell_command_parsing_result, stdout, stderr, error_code, output_channels) {
    // Terminology: Stream = outputs stream from a command, can be "stdout" or "stderr". Channel = a method for this application to present the output ot user, e.g. "notification".
    const shell_command_configuration = t_shell_command.getConfiguration(); // TODO: Refactor OutputChannels to use TShellCommand instead of the configuration objects directly.
    // Insert stdout and stderr to an object in a correct order
    let output = {};
    if (stdout.length && stderr.length) {
        // Both stdout and stderr have content
        // Decide the output order == Find out which data stream should be processed first, stdout or stderr.
        switch (shell_command_configuration.output_channel_order) {
            case "stdout-first":
                output = {
                    stdout: stdout,
                    stderr: stderr,
                };
                break;
            case "stderr-first":
                output = {
                    stderr: stderr,
                    stdout: stdout,
                };
                break;
        }
    }
    else if (stdout.length) {
        // Only stdout has content
        output = {
            stdout: stdout,
        };
    }
    else if (stderr.length) {
        // Only stderr has content
        output = {
            stderr: stderr,
        };
    }
    else {
        // Neither stdout nor stderr have content
        // Provide empty output, some output channels will process it, while other will just ignore it.
        output = {
            "stdout": "",
        };
    }
    // Should stderr be processed same time with stdout?
    if (output_channels.stdout === output_channels.stderr) {
        // Stdout and stderr use the same channel.
        // Make one handling call.
        handle_stream(plugin, t_shell_command, shell_command_parsing_result, output_channels.stdout, output, error_code);
    }
    else {
        // Stdout and stderr use different channels.
        // Make two handling calls.
        let output_stream_name;
        for (output_stream_name in output) {
            const output_channel_name = output_channels[output_stream_name];
            const output_message = output[output_stream_name];
            const separated_output = {};
            separated_output[output_stream_name] = output_message;
            handle_stream(plugin, t_shell_command, shell_command_parsing_result, output_channel_name, separated_output, error_code);
        }
    }
}
async function handle_stream(plugin, t_shell_command, shell_command_parsing_result, output_channel_name, output, error_code) {
    // Check if the output should be ignored
    if ("ignore" !== output_channel_name) {
        // The output should not be ignored.
        // Check that an output channel class exists
        if (undefined === outputChannelClasses[output_channel_name]) {
            throw new Error("No output channel class found for channel '" + output_channel_name + "'.");
        }
        // Instantiate the channel
        const outputChannel = initializeOutputChannel(output_channel_name, plugin, t_shell_command, shell_command_parsing_result, "buffered", null);
        // Perform handling the output
        await outputChannel.handleBuffered(output, error_code);
    }
}
function startRealtimeOutputHandling(plugin, tShellCommand, shellCommandParsingResult, outputChannelCodes, processTerminator) {
    const outputChannels = {};
    // stdout
    if ("ignore" !== outputChannelCodes.stdout) {
        outputChannels.stdout = initializeOutputChannel(outputChannelCodes.stdout, plugin, tShellCommand, shellCommandParsingResult, "realtime", processTerminator);
    }
    // stderr
    if ("ignore" !== outputChannelCodes.stderr) {
        if (outputChannelCodes.stderr === outputChannelCodes.stdout) {
            // stderr should use the same channel instance as stdout.
            outputChannels.stderr = outputChannels.stdout;
        }
        else {
            // stderr uses a different channel than stdout.
            outputChannels.stderr = initializeOutputChannel(outputChannelCodes.stderr, plugin, tShellCommand, shellCommandParsingResult, "realtime", processTerminator);
        }
    }
    return outputChannels;
}
function getOutputChannelsOptionList(output_stream) {
    const list = { ignore: "Ignore" };
    for (const name in outputChannelClasses) {
        const channelClass = outputChannelClasses[name];
        // Check that the stream is suitable for the channel
        if (channelClass.acceptsOutputStream(output_stream)) {
            list[name] = channelClass.getTitle(output_stream);
        }
    }
    return list;
}
function getOutputChannelClasses() {
    return outputChannelClasses;
}
function initializeOutputChannel(channelCode, plugin, tShellCommand, shellCommandParsingResult, outputHandlingMode, processTerminator) {
    // @ts-ignore TODO: Find out how to tell TypeScript that a subclass is being instatiated instead of the abstract base class:
    return new outputChannelClasses[channelCode](plugin, tShellCommand, shellCommandParsingResult, outputHandlingMode, processTerminator);
}
function registerOutputChannel(channelCode, channelClass) {
    if (undefined !== outputChannelClasses[channelCode]) {
        throw new Error("OutputChannel named '" + channelCode + "' is already registered!");
    }
    outputChannelClasses[channelCode] = channelClass;
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
const PlatformShells = {
    darwin: {
        "/bin/bash": "Bash",
        "/bin/dash": "Dash",
        "/bin/zsh": "Zsh (Z shell)",
    },
    linux: {
        "/bin/bash": "Bash",
        "/bin/dash": "Dash",
        "/bin/zsh": "Zsh (Z shell)",
    },
    win32: {
        "pwsh.exe": "PowerShell Core",
        "PowerShell.exe": "PowerShell 5",
        "CMD.EXE": "cmd.exe",
    },
};
function getUsersDefaultShell() {
    if (isWindows()) {
        if (undefined === process.env.ComSpec) {
            throw new Error("process.env.ComSpec is not a string.");
        }
        return process.env.ComSpec;
    }
    else {
        if (undefined === process.env.SHELL) {
            throw new Error("process.env.SHELL is not a string.");
        }
        return process.env.SHELL;
    }
}
function isShellSupported(shell) {
    const shell_file_name = extractFileName(shell);
    const supported_shells = Object.getOwnPropertyNames(PlatformShells[getOperatingSystem()]);
    // Linux and macOS: Add the ambiguous 'sh' as a supported shell. It's not present in PlatformShells, because it's
    // not desired to be an explicitly selectable shell as it's uncertain, which shell it actually points to. But have
    // it supported when it comes from the "Use system default (sh)" option.
    if (!isWindows()) {
        // The platform is either Linux or macOS.
        // Add 'sh' support.
        supported_shells.push("sh");
    }
    for (const supported_shell_path of supported_shells) {
        // Check that the shell file names match. It doesn't matter in which directory the shell is located in.
        if (extractFileName(supported_shell_path).toLowerCase() === shell_file_name.toLowerCase()) {
            // The shell can be considered to be supported.
            return true;
        }
    }
    return false;
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function getDefaultSettings(is_new_installation) {
    return {
        // Common:
        settings_version: is_new_installation
            ? SC_Plugin.SettingsVersion // For new installations, a specific settings version number can be used, as migrations do not need to be taken into account.
            : "prior-to-0.7.0" // This will be substituted by ShellCommandsPlugin.saveSettings() when the settings are saved.
        ,
        // Hidden settings (no UI controls in the settings panel)
        debug: false,
        obsidian_command_palette_prefix: "Execute: ",
        // Variables:
        preview_variables_in_command_palette: true,
        show_autocomplete_menu: true,
        // Environments:
        working_directory: "",
        default_shells: {},
        environment_variable_path_augmentations: {},
        // Output:
        error_message_duration: 20,
        notification_message_duration: 10,
        execution_notification_mode: "disabled",
        output_channel_clipboard_also_outputs_to_notification: true,
        // Events:
        enable_events: true,
        // Modals:
        approve_modals_by_pressing_enter_key: true,
        // Shell commands:
        max_visible_lines_in_shell_command_fields: false,
        shell_commands: [],
        // Prompts:
        prompts: [],
        // Additional configuration for built-in variables:
        builtin_variables: {},
        // Custom variables
        custom_variables: [],
        // Output wrappers
        output_wrappers: [],
    };
}
const PlatformNames = {
    darwin: "Macintosh",
    linux: "Linux",
    win32: "Windows",
};
const CommandPaletteOptions = {
    enabled: "Command palette & hotkeys",
    unlisted: "Hotkeys only",
    disabled: "Excluded",
};

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class ShellCommandExecutor {
    constructor(plugin, t_shell_command, 
    /** Needed for Preactions to be able to access all variables, in case any variables are used by a Preaction. Use null, if the shell command execution happens outside of any event context. */
    sc_event) {
        this.plugin = plugin;
        this.t_shell_command = t_shell_command;
        this.sc_event = sc_event;
    }
    /**
     * Performs preactions, and if they all give resolved Promises, executes the shell command.
     */
    async doPreactionsAndExecuteShellCommand(parsing_process, overriding_output_channel) {
        const preactions = this.t_shell_command.getPreactions();
        // Does an already started ParsingProcess exist?
        if (!parsing_process) {
            // No ParsingProcess yet.
            // Create one and parse all variables that are safe to parse before preactions.
            debugLog("Going to prepare possible Preactions, but will first start a variable parsing process. Depending on possible Preactions, this might not yet parse all variables.");
            parsing_process = this.t_shell_command.createParsingProcess(this.sc_event);
            // Parse the first set of variables, not all sets.
            if (!await parsing_process.process()) {
                // Some errors happened.
                debugLog("Will not prepare possible Preactions, because the parsing process failed. Will cancel shell command execution.");
                parsing_process.displayErrorMessages();
                return;
            }
        }
        else {
            debugLog("Going to prepare possible Preactions with an already started variable parsing process.");
        }
        // Create a pipeline for preactions.
        let preaction_pipeline = Promise.resolve(true); // Will contain a series of preaction performs.
        // Confirm execution from a user, if needed.
        // I haven't decided yet if I want to move this to be its own Preaction subclass. Might make sense, but requires configuration migration.
        if (this.t_shell_command.getConfiguration().confirm_execution) {
            preaction_pipeline = preaction_pipeline.then(() => {
                debugLog("Asking a confirmation from a user to execute shell command #" + this.t_shell_command.getId());
                return new Promise((resolve, reject) => {
                    const confirmation_modal = new ConfirmationModal(this.plugin, this.t_shell_command.getAliasOrShellCommand(), "Execute this shell command?", "Yes, execute");
                    confirmation_modal.open();
                    confirmation_modal.promise.then((execution_confirmed) => {
                        if (execution_confirmed) {
                            // The PromptModal has been closed.
                            // Check if user wanted to execute the shell command or cancel.
                            if (execution_confirmed) {
                                // User wants to execute.
                                debugLog("User confirmed to execute shell command #" + this.t_shell_command.getId());
                                resolve(true);
                            }
                            else {
                                // User wants to cancel.
                                debugLog("User cancelled execution of shell command #" + this.t_shell_command.getId());
                                resolve(false);
                            }
                        }
                    });
                });
            });
        }
        // Perform preactions
        preactions.forEach((preaction) => {
            debugLog(`Adding Preaction of type '${preaction.configuration.type}' to pipeline.`);
            preaction_pipeline = preaction_pipeline.then(() => {
                debugLog(`Calling Preaction of type '${preaction.configuration.type}'.`);
                if (!parsing_process) {
                    // Should have a ParsingProcess at this point.
                    throw new Error("No parsing process. Cannot do preaction.");
                }
                return preaction.perform(parsing_process, this.sc_event);
            });
        });
        if (0 === preactions.length) {
            debugLog("No Preactions to perform. This is ok.");
        }
        preaction_pipeline.then(async (can_execute) => {
            if (can_execute) {
                // Parse either all variables, or if some variables are already parsed, then just the rest. Might also be that
                // all variables are already parsed.
                debugLog("Parsing all the rest of the variables (if there are any left).");
                if (!parsing_process) {
                    // Should have a ParsingProcess at this point.
                    throw new Error("No parsing process. Cannot execute shell command.");
                }
                if (await parsing_process.processRest()) {
                    // Parsing the rest of the variables succeeded
                    // Execute the shell command.
                    const parsing_results = parsing_process.getParsingResults();
                    const shell_command_parsing_result = {
                        shell_command: parsing_results["shell_command"].parsed_content,
                        alias: parsing_results["alias"].parsed_content,
                        environment_variable_path_augmentation: parsing_results.environment_variable_path_augmentation.parsed_content,
                        stdinContent: parsing_results.stdinContent?.parsed_content,
                        output_wrapper_stdout: parsing_results.output_wrapper_stdout?.parsed_content,
                        output_wrapper_stderr: parsing_results.output_wrapper_stderr?.parsed_content,
                        succeeded: true,
                        error_messages: [],
                    };
                    debugLog("Will call ShellCommandExecutor.executeShellCommand().");
                    this.executeShellCommand(shell_command_parsing_result, overriding_output_channel);
                }
                else {
                    // Parsing has failed.
                    debugLog("Parsing the rest of the variables failed.");
                    parsing_process.displayErrorMessages();
                }
            }
            else {
                // Cancel execution
                debugLog("Shell command execution cancelled.");
            }
        });
    }
    /**
     * Does not ask for confirmation before execution. This should only be called if: a) a confirmation is already asked from a user, or b) this command is defined not to need a confirmation.
     * Use confirmAndExecuteShellCommand() instead to have a confirmation asked before the execution.
     *
     * @param shell_command_parsing_result The actual shell command that will be executed is taken from this object's '.shell_command' property.
     * @param overriding_output_channel Optional. If specified, all output streams will be directed to this output channel. Otherwise, output channels are determined from this.t_shell_command.
     */
    executeShellCommand(shell_command_parsing_result, overriding_output_channel) {
        const working_directory = this.getWorkingDirectory();
        // Define output channels
        let outputChannels = this.t_shell_command.getOutputChannels();
        if (overriding_output_channel) {
            // Ignore the shell command's normal channels and use temporarily something else.
            outputChannels = {
                'stdout': overriding_output_channel,
                'stderr': overriding_output_channel,
            };
        }
        // Check that the shell command is not empty
        const shell_command = shell_command_parsing_result.shell_command.trim();
        if (!shell_command.length) {
            // It is empty
            const error_message = this.getErrorMessageForEmptyShellCommand();
            debugLog(error_message);
            this.plugin.newError(error_message);
            return;
        }
        // Check that the currently defined shell is supported by this plugin. If using system default shell, it's possible
        // that the shell is something that is not supported. Also, the settings file can be edited manually, and incorrect
        // shell can be written there.
        const shell = this.t_shell_command.getShell();
        if (!isShellSupported(shell)) {
            debugLog("Shell is not supported: " + shell);
            this.plugin.newError("This plugin does not support the following shell: " + shell);
            return;
        }
        // Define an object for environment variables.
        const environment_variables = cloneObject(process.env); // Need to clone process.env, otherwise the modifications below will be stored permanently until Obsidian is hard-restarted (= closed and launched again).
        // Augment the PATH environment variable (if wanted)
        const augmented_path = this.augmentPATHEnvironmentVariable(shell_command_parsing_result.environment_variable_path_augmentation);
        if (augmented_path.length > 0) {
            environment_variables[getPATHEnvironmentVariableName()] = augmented_path;
        }
        // Check that the working directory exists and is a folder
        if (!fs__namespace.existsSync(working_directory)) {
            // Working directory does not exist
            // Prevent execution
            debugLog("Working directory does not exist: " + working_directory);
            this.plugin.newError("Working directory does not exist: " + working_directory);
        }
        else if (!fs__namespace.lstatSync(working_directory).isDirectory()) {
            // Working directory is not a directory.
            // Prevent execution
            debugLog("Working directory exists but is not a folder: " + working_directory);
            this.plugin.newError("Working directory exists but is not a folder: " + working_directory);
        }
        else {
            // Working directory is OK
            // Prepare execution options
            const options = {
                "cwd": working_directory,
                "shell": shell,
                "env": environment_variables,
            };
            // Execute the shell command
            debugLog("Executing command " + shell_command + " in " + working_directory + "...");
            try {
                const child_process$1 = child_process.spawn(shell_command, options);
                // Pass stdin content (if defined)
                if (undefined !== shell_command_parsing_result.stdinContent) {
                    // Stdin content is defined
                    debugLog("Stdin content is present in parsing result. Will write it to the process.");
                    if (null === child_process$1.stdin) {
                        // noinspection ExceptionCaughtLocallyJS: The exception is caught locally below, but it's ok because it's then rethrown as the error message does not match '/spawn\s+ENAMETOOLONG/i'.
                        throw new Error("Shell command execution process does not have a standard input stream (stdin).");
                    }
                    child_process$1.stdin.write(shell_command_parsing_result.stdinContent);
                    child_process$1.stdin.end();
                }
                else {
                    debugLog("No stdin content is present in parsing result.");
                }
                // Common error handling regardless of output handling mode
                child_process$1.on("error", (error) => {
                    // Probably most errors will NOT end up here, I guess this event occurs for some rare errors.
                    //
                    // A quote from https://nodejs.org/api/child_process.html#event-error (read 2022-10-29):
                    // > The 'error' event is emitted whenever:
                    // > - The process could not be spawned, or
                    // > - The process could not be killed, or
                    // > - Sending a message to the child process failed.
                    debugLog("Shell command failed to execute: Received a non-stderr error message: " + error.message);
                    this.plugin.newError("Shell command failed to execute. Error: " + error.message);
                });
                // Define output encoding
                if (null === child_process$1.stdout || null == child_process$1.stderr) {
                    // The exception is caught locally below, but it's ok because it's then rethrown as the error message does not match '/spawn\s+ENAMETOOLONG/i'.
                    throw new Error("Child process's stdout and/or stderr stream is null.");
                }
                child_process$1.stdout.setEncoding("utf8"); // Receive stdout and ...
                child_process$1.stderr.setEncoding("utf8"); // ... stderr as strings, not as Buffer objects.
                // Define a terminator
                const processTerminator = () => {
                    child_process$1.kill("SIGTERM");
                };
                // Hook into child_process for output handling
                switch (this.t_shell_command.getOutputHandlingMode()) {
                    case "buffered": {
                        // Output will be buffered and handled as a single batch.
                        this.handleBufferedOutput(child_process$1, shell_command_parsing_result, outputChannels);
                        break;
                    }
                    case "realtime": {
                        // Output will be handled on-the-go.
                        this.handleRealtimeOutput(child_process$1, shell_command_parsing_result, outputChannels, processTerminator);
                    }
                }
                // Display a notification of the execution (if wanted).
                if ("disabled" !== this.plugin.settings.execution_notification_mode) {
                    this.showExecutionNotification(child_process$1, shell_command, this.plugin.settings.execution_notification_mode, processTerminator);
                }
            }
            catch (exception) {
                // An exception has happened.
                // Check if the shell command was too long.
                if (exception.message.match(/spawn\s+ENAMETOOLONG/i)) {
                    // It was too long. Show an error message.
                    this.plugin.newError("Shell command execution failed because it's too long: " + shell_command.length + " characters. (Unfortunately the max limit is unknown).");
                }
                else {
                    // The shell command was not too long, this exception is about something else.
                    // Rethrow the exception.
                    throw exception;
                }
            }
        }
    }
    handleBufferedOutput(child_process, shell_command_parsing_result, outputChannels) {
        child_process.on("exit", (exitCode) => {
            // exitCode is null if user terminated the process. Reference: https://nodejs.org/api/child_process.html#event-exit (read on 2022-11-27).
            // Get outputs
            if (null === child_process.stdout || null == child_process.stderr) {
                // The exception is caught locally below, but it's ok because it's then rethrown as the error message does not match '/spawn\s+ENAMETOOLONG/i'.
                throw new Error("Child process's stdout and/or stderr stream is null.");
            }
            const stdout = child_process.stdout.read() ?? "";
            let stderr = child_process.stderr.read() ?? ""; // let instead of const: stderr can be emptied later due to ignoring.
            // Did the shell command execute successfully?
            if (exitCode === null || exitCode > 0) {
                // Some error occurred
                debugLog("Command executed and failed. Error number: " + exitCode + ". Stderr: " + stderr);
                // Check if this error should be displayed to the user or not
                if (null !== exitCode && this.t_shell_command.getIgnoreErrorCodes().contains(exitCode)) {
                    // The user has ignored this error.
                    debugLog("User has ignored this error, so won't display it.");
                    // Handle only stdout output stream
                    stderr = "";
                    exitCode = null; // TODO: consider if exitCode should just be left untouched. It could be informative to 'Ask after execution' output channel that shows exit code to user.
                }
                else {
                    // The error can be shown.
                    debugLog("Will display the error to user.");
                }
                // Handle at least stdout (and maybe stderr) output stream
                handleBufferedOutput(this.plugin, this.t_shell_command, shell_command_parsing_result, stdout, stderr, exitCode, outputChannels);
            }
            else {
                // Probably no errors, but do one more check.
                // Even when 'error' is null and everything should be ok, there may still be error messages outputted in stderr.
                if (stderr.length > 0) {
                    // Check a special case: should error code 0 be ignored?
                    if (this.t_shell_command.getIgnoreErrorCodes().contains(0)) {
                        // Exit code 0 is on the ignore list, so suppress stderr output.
                        stderr = "";
                        debugLog("Shell command executed: Encountered error code 0, but stderr is ignored.");
                    }
                    else {
                        debugLog("Shell command executed: Encountered error code 0, and stderr will be relayed to an output handler.");
                    }
                }
                else {
                    debugLog("Shell command executed: No errors.");
                }
                // Handle output
                handleBufferedOutput(this.plugin, this.t_shell_command, shell_command_parsing_result, stdout, stderr, 0, outputChannels); // Use zero as an error code instead of null (0 means no error). If stderr happens to contain something, exit code 0 gets displayed in an error balloon (if that is selected as a channel for stderr).
            }
        });
    }
    handleRealtimeOutput(childProcess, shell_command_parsing_result, outputChannelCodes, processTerminator) {
        // Prepare output channels
        const outputChannels = startRealtimeOutputHandling(this.plugin, this.t_shell_command, shell_command_parsing_result, outputChannelCodes, processTerminator);
        // Define an output handler
        const handleNewOutputContent = async (outputStreamName, readableStream) => {
            if (null === childProcess.stdout || null == childProcess.stderr) {
                throw new Error("Child process's stdout and/or stderr stream is null.");
            }
            // Don't emit new events while the current handling is in progress. (I think) it might cause a race condition where a simultaneous handling could overwrite another handling's data. Pause both streams, not just the current one, to maintain correct handling order also between the two streams.
            childProcess.stdout.pause();
            childProcess.stderr.pause();
            const outputContent = readableStream.read() ?? "";
            const outputChannel = outputChannels[outputStreamName];
            if (undefined === outputChannel) {
                throw new Error("Output channel is undefined.");
            }
            await outputChannel.handleRealtime(outputStreamName, outputContent);
            // Can emit new events again.
            childProcess.stdout.resume();
            childProcess.stderr.resume();
        };
        // Hook into output streams' (such as stdout and stderr) output retrieving events.
        // Note that there might be just one stream, e.g. only stderr, if stdout is ignored. In the future, there might also be more than two streams, when custom streams are implemented.
        for (const outputStreamName of Object.getOwnPropertyNames(outputChannels)) {
            const readableStream = childProcess[outputStreamName];
            if (null === readableStream) {
                throw new Error("Child process's readable stream '" + outputStreamName + "' is null.");
            }
            readableStream.on("readable", () => handleNewOutputContent(outputStreamName, readableStream));
        }
        // Hook into exit events
        childProcess.on("exit", (exitCode, signal /* TODO: Pass signal to channels so it can be shown to users in the future */) => {
            // Call all OutputChannels' endRealtime().
            const alreadyCalledChannelCodes = [];
            for (const outputStreamName of Object.getOwnPropertyNames(outputChannels)) {
                const outputChannel = outputChannels[outputStreamName];
                if (undefined === outputChannel) {
                    throw new Error("Output channel is undefined.");
                }
                const outputChannelCode = outputChannelCodes[outputStreamName];
                // Ensure this OutputChannel has not yet been called.
                if (!alreadyCalledChannelCodes.includes(outputChannelCode)) {
                    // Not yet called, so do the call.
                    outputChannel.endRealtime(exitCode);
                    // Mark that this channel's endRealtime() has already been called. Solves a situation where stderr and stdout uses the same channel, in which case endRealtime() should not be accidentally called twice.
                    alreadyCalledChannelCodes.push(outputChannelCode);
                }
            }
        });
    }
    getWorkingDirectory() {
        // Returns either a user defined working directory, or an automatically detected one.
        const working_directory = this.plugin.settings.working_directory;
        if (working_directory.length == 0) {
            // No working directory specified, so use the vault directory.
            return getVaultAbsolutePath(this.plugin.app);
        }
        else if (!path__namespace.isAbsolute(working_directory)) {
            // The working directory is relative.
            // Help to make it refer to the vault's directory. Without this, the relative path would refer to Obsidian's installation directory (at least on Windows).
            return path__namespace.join(getVaultAbsolutePath(this.plugin.app), working_directory);
        }
        return working_directory;
    }
    augmentPATHEnvironmentVariable(path_augmentation) {
        path_augmentation = convertNewlinesToPATHSeparators(path_augmentation, getOperatingSystem());
        // Check if there's anything to augment.
        if (path_augmentation.length > 0) {
            // Augment.
            const original_path = process.env[getPATHEnvironmentVariableName()];
            if (undefined === original_path) {
                throw new Error("process.env does not contain '" + getPATHEnvironmentVariableName() + "'.");
            }
            let augmented_path;
            if (path_augmentation.contains(original_path)) {
                // The augmentation contains the original PATH.
                // Simply replace the whole original PATH with the augmented one, as there's no need to care about including
                // the original content.
                debugLog("Augmenting environment variable PATH so it will become " + path_augmentation);
                augmented_path = path_augmentation;
            }
            else {
                // The augmentation does not contain the original PATH.
                // Instead of simply replacing the original PATH, append the augmentation after it.
                const separator = getPATHSeparator(getOperatingSystem());
                debugLog("Augmenting environment variable PATH by adding " + separator + path_augmentation + " after it.");
                augmented_path = original_path + separator + path_augmentation;
            }
            debugLog("PATH augmentation result: " + augmented_path);
            return augmented_path;
        }
        else {
            // No augmenting is needed.
            debugLog("No augmentation is defined for environment variable PATH. This is completely ok.");
            return "";
        }
    }
    /**
     * This method should only be called if it's first checked that neither shell command version for the current platform nor a 'default' version exists.
     *
     * @private
     */
    getErrorMessageForEmptyShellCommand() {
        if (this.t_shell_command.getNonEmptyPlatformIds().length > 0) {
            // The shell command contains versions for other platforms, but not for the current one.
            const current_platform_name = PlatformNames[getOperatingSystem()];
            const version_word = this.t_shell_command.getNonEmptyPlatformIds().length > 1 ? "versions" : "a version";
            const other_platform_names = this.t_shell_command.getNonEmptyPlatformIds().map(platform_id => PlatformNames[platform_id]).join(" and ");
            return `The shell command does not have a version for ${current_platform_name}, it only has ${version_word} for ${other_platform_names}.`;
        }
        else {
            // The shell command doesn't contain a version for any platforms, it's completely empty.
            return "The shell command is empty. :(";
        }
    }
    /**
     * Displays a notification balloon indicating a user that a shell command is being executed.
     *
     * @param child_process
     * @param shell_command
     * @param execution_notification_mode
     * @param processTerminator Will be called if user clicks 'Request to terminate the process' icon.
     * @private
     */
    showExecutionNotification(child_process, shell_command, execution_notification_mode, processTerminator) {
        const createRequestTerminatingButton = (notice) => {
            // @ts-ignore Notice.noticeEl belongs to Obsidian's PRIVATE API, and it may change without a prior notice. Only
            // create the button if noticeEl exists and is an HTMLElement.
            const noticeEl = notice.noticeEl;
            if (undefined !== noticeEl && noticeEl instanceof HTMLElement) {
                this.plugin.createRequestTerminatingButton(noticeEl, processTerminator);
            }
        };
        const execution_notification_message = "Executing: " + (this.t_shell_command.getAlias() || shell_command);
        switch (execution_notification_mode) {
            case "quick": {
                // Retrieve the timeout from settings defined by a user.
                const processNotification = this.plugin.newNotification(execution_notification_message, undefined);
                createRequestTerminatingButton(processNotification);
                break;
            }
            case "permanent": {
                // Show the notification until the process ends.
                const processNotification = this.plugin.newNotification(execution_notification_message, 0);
                createRequestTerminatingButton(processNotification);
                // Hide the notification when the process finishes.
                child_process.on("exit", () => processNotification.hide());
                break;
            }
            case "if-long": {
                // Only show the notification if the process runs for an extended period of time (defined below).
                window.setTimeout(() => {
                    // Check if the process is still running.
                    if (null === child_process.exitCode && !child_process.killed) {
                        // The process is still running.
                        // Display notification.
                        const processNotification = this.plugin.newNotification(execution_notification_message, 0);
                        createRequestTerminatingButton(processNotification);
                        // Hide the notification when the process finishes.
                        child_process.on("exit", () => processNotification.hide());
                    }
                }, 2000); // If you change the timeout, change documentation, too!
                break;
            }
        }
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Instance {
    constructor(model, configuration, parent_instance_or_configuration) {
        this.model = model;
        this.configuration = configuration;
        debugLog(this.constructor.name + ": Creating a new instance.");
        // Determine parent type
        if (parent_instance_or_configuration instanceof Instance) {
            // It's an instance object
            this.parent_instance = parent_instance_or_configuration;
            this.parent_configuration = this.parent_instance.configuration;
        }
        else {
            // It's a configuration object.
            // No parent instance is available, so probably this is about SC_MainSettings object, as it does not have Model/Instance classes (at least yet).
            this.parent_instance = null; // It's null already, but do this just to make a statement.
            this.parent_configuration = parent_instance_or_configuration;
        }
    }
    setIfValid(field, value) {
        return this.model.validateValue(this, field, value).then(() => {
            this.configuration[field] = value;
        });
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Model {
    constructor(plugin) {
        this.plugin = plugin;
    }
    createSettingFields(instance, parent_element, with_deletion = true) {
        debugLog(this.constructor.name + ": Creating setting fields.");
        // Create a container
        const setting_fields_container = parent_element.createDiv(); // Create a nested container that can be easily deleted if the instance is deleted.
        const main_setting_field = this._createSettingFields(instance, setting_fields_container);
        if (with_deletion) {
            main_setting_field.addExtraButton(button => button
                .setIcon("trash")
                .setTooltip("Delete this " + this.getSingularName().toLocaleLowerCase())
                .onClick(() => {
                // The trash icon has been clicked
                // Open up a modal asking for confirmation if the instance can be deleted from this.parent_configuration.
                const confirmation_modal = new ConfirmationModal(this.plugin, "Delete " + this.getSingularName().toLocaleLowerCase() + ": " + instance.getTitle(), "Are you sure you want to delete this " + this.getSingularName().toLocaleLowerCase() + "?", "Yes, delete");
                confirmation_modal.open();
                confirmation_modal.promise.then(async (deletion_confirmed) => {
                    if (deletion_confirmed) {
                        // User has confirmed the deletion.
                        // Delete the configuration and remove the instance from custom collections.
                        this.deleteInstance(instance);
                        // Delete setting fields.
                        setting_fields_container.remove();
                        // Save settings
                        await this.plugin.saveSettings();
                    }
                });
            }));
        }
        return main_setting_field;
    }
    /**
     * Deletes the instance from configuration, and calls _deleteChild() which will delete the instance from custom collections.
     *
     * Can be made public if needed.
     */
    deleteInstance(instance) {
        debugLog(this.constructor.name + ": Deleting an instance.");
        this._deleteInstance(instance);
        const relation = this.defineParentConfigurationRelation(instance);
        switch (relation.type) {
            // case "one-to-one": // TODO: Uncomment when first model that needs this is implemented.
            // This is a relation where 'key' points directly to the instance's configuration.
            // delete this.parent_configuration[this.relation.key];
            // break;
            case "one-to-many-index": {
                // This is a relation where 'key' points to an indexed array of instance configurations. Use 'index' to pick the correct instance configuration.
                instance.parent_configuration[relation.key].splice(relation.index, 1); // Do not use delete, as it would place null in the list.
                break;
            }
            case "one-to-many-id": {
                // This is a relation where 'key' points to an indexed array of instance configurations. Use 'id' to determine the correct index.
                const index = this.idToIndex(instance.parent_configuration[relation.key], relation.id);
                if (null === index) {
                    // Something went wrong
                    throw new Error(`${this.constructor.name}.deleteInstance(): Could not find an index for id ${relation.id}.`);
                }
                instance.parent_configuration[relation.key].splice(index, 1); // Do not use delete, as it would place null in the list.
                break;
            }
        }
    }
    idToIndex(configurations, id) {
        let result_index = null;
        configurations.forEach((instance_configuration, index) => {
            if (instance_configuration.id === id) {
                // This is the correct configuration.
                result_index = index;
            }
        });
        return result_index;
    }
    /**
     * This should delete the instance from custom collections. It should be overridden by all Instance classes that have deletable children.
     */
    _deleteInstance(instance) {
        throw new Error(this.constructor.name + ".deleteInstance(): This class does not override _deleteInstance() method. Maybe the class is not supposed to have children?");
    }
}
// Model class collection
const model_classes = new Map();
function introduceModelClass(model_class) {
    model_classes.set(model_class.constructor.name, model_class);
}
function getModel(model_class_name) {
    return model_classes.get(model_class_name);
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputWrapper extends Instance {
    constructor(model, plugin, configuration, parent_configuration) {
        super(model, configuration, parent_configuration);
        this.model = model;
        this.plugin = plugin;
        this.configuration = configuration;
        this.parent_configuration = parent_configuration;
        // Introduce the ID to an ID generator so that it won't accidentally generate the same ID again when creating new OutputWrappers.
        getIDGenerator().addReservedID(configuration.id);
    }
    getID() {
        return this.configuration.id;
    }
    getTitle() {
        return this.configuration.title;
    }
    getContent() {
        return this.configuration.content;
    }
    getConfiguration() {
        return this.configuration;
    }
}

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function createCommonjsModule(fn) {
  var module = { exports: {} };
	return fn(module, module.exports), module.exports;
}

var autocomplete = createCommonjsModule(function (module, exports) {
(function (global, factory) {
  module.exports = factory() ;
}(commonjsGlobal, (function () {
  /*
   * https://github.com/kraaden/autocomplete
   * Copyright (c) 2016 Denys Krasnoshchok
   * MIT License
   */
  function autocomplete(settings) {
      // just an alias to minimize JS file size
      var doc = document;
      var container = settings.container || doc.createElement("div");
      var containerStyle = container.style;
      var userAgent = navigator.userAgent;
      var mobileFirefox = ~userAgent.indexOf("Firefox") && ~userAgent.indexOf("Mobile");
      var debounceWaitMs = settings.debounceWaitMs || 0;
      var preventSubmit = settings.preventSubmit || false;
      var disableAutoSelect = settings.disableAutoSelect || false;
      // 'keyup' event will not be fired on Mobile Firefox, so we have to use 'input' event instead
      var keyUpEventName = mobileFirefox ? "input" : "keyup";
      var items = [];
      var inputValue = "";
      var minLen = 2;
      var showOnFocus = settings.showOnFocus;
      var selected;
      var keypressCounter = 0;
      var debounceTimer;
      if (settings.minLength !== undefined) {
          minLen = settings.minLength;
      }
      if (!settings.input) {
          throw new Error("input undefined");
      }
      var input = settings.input;
      container.className = "autocomplete " + (settings.className || "");
      // IOS implementation for fixed positioning has many bugs, so we will use absolute positioning
      containerStyle.position = "absolute";
      /**
       * Detach the container from DOM
       */
      function detach() {
          var parent = container.parentNode;
          if (parent) {
              parent.removeChild(container);
          }
      }
      /**
       * Clear debouncing timer if assigned
       */
      function clearDebounceTimer() {
          if (debounceTimer) {
              window.clearTimeout(debounceTimer);
          }
      }
      /**
       * Attach the container to DOM
       */
      function attach() {
          if (!container.parentNode) {
              doc.body.appendChild(container);
          }
      }
      /**
       * Check if container for autocomplete is displayed
       */
      function containerDisplayed() {
          return !!container.parentNode;
      }
      /**
       * Clear autocomplete state and hide container
       */
      function clear() {
          // prevent the update call if there are pending AJAX requests
          keypressCounter++;
          items = [];
          inputValue = "";
          selected = undefined;
          detach();
      }
      /**
       * Update autocomplete position
       */
      function updatePosition() {
          if (!containerDisplayed()) {
              return;
          }
          containerStyle.height = "auto";
          containerStyle.width = input.offsetWidth + "px";
          var maxHeight = 0;
          var inputRect;
          function calc() {
              var docEl = doc.documentElement;
              var clientTop = docEl.clientTop || doc.body.clientTop || 0;
              var clientLeft = docEl.clientLeft || doc.body.clientLeft || 0;
              var scrollTop = window.pageYOffset || docEl.scrollTop;
              var scrollLeft = window.pageXOffset || docEl.scrollLeft;
              inputRect = input.getBoundingClientRect();
              var top = inputRect.top + input.offsetHeight + scrollTop - clientTop;
              var left = inputRect.left + scrollLeft - clientLeft;
              containerStyle.top = top + "px";
              containerStyle.left = left + "px";
              maxHeight = window.innerHeight - (inputRect.top + input.offsetHeight);
              if (maxHeight < 0) {
                  maxHeight = 0;
              }
              containerStyle.top = top + "px";
              containerStyle.bottom = "";
              containerStyle.left = left + "px";
              containerStyle.maxHeight = maxHeight + "px";
          }
          // the calc method must be called twice, otherwise the calculation may be wrong on resize event (chrome browser)
          calc();
          calc();
          if (settings.customize && inputRect) {
              settings.customize(input, inputRect, container, maxHeight);
          }
      }
      /**
       * Redraw the autocomplete div element with suggestions
       */
      function update() {
          // delete all children from autocomplete DOM container
          while (container.firstChild) {
              container.removeChild(container.firstChild);
          }
          // function for rendering autocomplete suggestions
          var render = function (item, currentValue) {
              var itemElement = doc.createElement("div");
              itemElement.textContent = item.label || "";
              return itemElement;
          };
          if (settings.render) {
              render = settings.render;
          }
          // function to render autocomplete groups
          var renderGroup = function (groupName, currentValue) {
              var groupDiv = doc.createElement("div");
              groupDiv.textContent = groupName;
              return groupDiv;
          };
          if (settings.renderGroup) {
              renderGroup = settings.renderGroup;
          }
          var fragment = doc.createDocumentFragment();
          var prevGroup = "#9?$";
          items.forEach(function (item) {
              if (item.group && item.group !== prevGroup) {
                  prevGroup = item.group;
                  var groupDiv = renderGroup(item.group, inputValue);
                  if (groupDiv) {
                      groupDiv.className += " group";
                      fragment.appendChild(groupDiv);
                  }
              }
              var div = render(item, inputValue);
              if (div) {
                  div.addEventListener("click", function (ev) {
                      settings.onSelect(item, input);
                      clear();
                      ev.preventDefault();
                      ev.stopPropagation();
                  });
                  if (item === selected) {
                      div.className += " selected";
                  }
                  fragment.appendChild(div);
              }
          });
          container.appendChild(fragment);
          if (items.length < 1) {
              if (settings.emptyMsg) {
                  var empty = doc.createElement("div");
                  empty.className = "empty";
                  empty.textContent = settings.emptyMsg;
                  container.appendChild(empty);
              }
              else {
                  clear();
                  return;
              }
          }
          attach();
          updatePosition();
          updateScroll();
      }
      function updateIfDisplayed() {
          if (containerDisplayed()) {
              update();
          }
      }
      function resizeEventHandler() {
          updateIfDisplayed();
      }
      function scrollEventHandler(e) {
          if (e.target !== container) {
              updateIfDisplayed();
          }
          else {
              e.preventDefault();
          }
      }
      function keyupEventHandler(ev) {
          var keyCode = ev.which || ev.keyCode || 0;
          var ignore = settings.keysToIgnore || [38 /* Up */, 13 /* Enter */, 27 /* Esc */, 39 /* Right */, 37 /* Left */, 16 /* Shift */, 17 /* Ctrl */, 18 /* Alt */, 20 /* CapsLock */, 91 /* WindowsKey */, 9 /* Tab */];
          for (var _i = 0, ignore_1 = ignore; _i < ignore_1.length; _i++) {
              var key = ignore_1[_i];
              if (keyCode === key) {
                  return;
              }
          }
          if (keyCode >= 112 /* F1 */ && keyCode <= 123 /* F12 */ && !settings.keysToIgnore) {
              return;
          }
          // the down key is used to open autocomplete
          if (keyCode === 40 /* Down */ && containerDisplayed()) {
              return;
          }
          startFetch(0 /* Keyboard */);
      }
      /**
       * Automatically move scroll bar if selected item is not visible
       */
      function updateScroll() {
          var elements = container.getElementsByClassName("selected");
          if (elements.length > 0) {
              var element = elements[0];
              // make group visible
              var previous = element.previousElementSibling;
              if (previous && previous.className.indexOf("group") !== -1 && !previous.previousElementSibling) {
                  element = previous;
              }
              if (element.offsetTop < container.scrollTop) {
                  container.scrollTop = element.offsetTop;
              }
              else {
                  var selectBottom = element.offsetTop + element.offsetHeight;
                  var containerBottom = container.scrollTop + container.offsetHeight;
                  if (selectBottom > containerBottom) {
                      container.scrollTop += selectBottom - containerBottom;
                  }
              }
          }
      }
      /**
       * Select the previous item in suggestions
       */
      function selectPrev() {
          if (items.length < 1) {
              selected = undefined;
          }
          else {
              if (selected === items[0]) {
                  selected = items[items.length - 1];
              }
              else {
                  for (var i = items.length - 1; i > 0; i--) {
                      if (selected === items[i] || i === 1) {
                          selected = items[i - 1];
                          break;
                      }
                  }
              }
          }
      }
      /**
       * Select the next item in suggestions
       */
      function selectNext() {
          if (items.length < 1) {
              selected = undefined;
          }
          if (!selected || selected === items[items.length - 1]) {
              selected = items[0];
              return;
          }
          for (var i = 0; i < (items.length - 1); i++) {
              if (selected === items[i]) {
                  selected = items[i + 1];
                  break;
              }
          }
      }
      function keydownEventHandler(ev) {
          var keyCode = ev.which || ev.keyCode || 0;
          if (keyCode === 38 /* Up */ || keyCode === 40 /* Down */ || keyCode === 27 /* Esc */) {
              var containerIsDisplayed = containerDisplayed();
              if (keyCode === 27 /* Esc */) {
                  clear();
              }
              else {
                  if (!containerIsDisplayed || items.length < 1) {
                      return;
                  }
                  keyCode === 38 /* Up */
                      ? selectPrev()
                      : selectNext();
                  update();
              }
              ev.preventDefault();
              if (containerIsDisplayed) {
                  ev.stopPropagation();
              }
              return;
          }
          if (keyCode === 13 /* Enter */) {
              if (selected) {
                  if (preventSubmit) {
                      ev.preventDefault();
                  }
                  settings.onSelect(selected, input);
                  clear();
              }
          }
      }
      function focusEventHandler() {
          if (showOnFocus) {
              startFetch(1 /* Focus */);
          }
      }
      function startFetch(trigger) {
          // If multiple keys were pressed, before we get an update from server,
          // this may cause redrawing autocomplete multiple times after the last key was pressed.
          // To avoid this, the number of times keyboard was pressed will be saved and checked before redraw.
          var savedKeypressCounter = ++keypressCounter;
          var inputText = input.value;
          var cursorPos = input.selectionStart || 0;
          if (inputText.length >= minLen || trigger === 1 /* Focus */) {
              clearDebounceTimer();
              debounceTimer = window.setTimeout(function () {
                  settings.fetch(inputText, function (elements) {
                      if (keypressCounter === savedKeypressCounter && elements) {
                          items = elements;
                          inputValue = inputText;
                          selected = (items.length < 1 || disableAutoSelect) ? undefined : items[0];
                          update();
                      }
                  }, trigger, cursorPos);
              }, trigger === 0 /* Keyboard */ ? debounceWaitMs : 0);
          }
          else {
              clear();
          }
      }
      function blurEventHandler() {
          // we need to delay clear, because when we click on an item, blur will be called before click and remove items from DOM
          setTimeout(function () {
              if (doc.activeElement !== input) {
                  clear();
              }
          }, 200);
      }
      /**
       * Fixes #26: on long clicks focus will be lost and onSelect method will not be called
       */
      container.addEventListener("mousedown", function (evt) {
          evt.stopPropagation();
          evt.preventDefault();
      });
      /**
       * Fixes #30: autocomplete closes when scrollbar is clicked in IE
       * See: https://stackoverflow.com/a/9210267/13172349
       */
      container.addEventListener("focus", function () { return input.focus(); });
      /**
       * This function will remove DOM elements and clear event handlers
       */
      function destroy() {
          input.removeEventListener("focus", focusEventHandler);
          input.removeEventListener("keydown", keydownEventHandler);
          input.removeEventListener(keyUpEventName, keyupEventHandler);
          input.removeEventListener("blur", blurEventHandler);
          window.removeEventListener("resize", resizeEventHandler);
          doc.removeEventListener("scroll", scrollEventHandler, true);
          clearDebounceTimer();
          clear();
      }
      // setup event handlers
      input.addEventListener("keydown", keydownEventHandler);
      input.addEventListener(keyUpEventName, keyupEventHandler);
      input.addEventListener("blur", blurEventHandler);
      input.addEventListener("focus", focusEventHandler);
      window.addEventListener("resize", resizeEventHandler);
      doc.addEventListener("scroll", scrollEventHandler, true);
      return {
          destroy: destroy
      };
  }

  return autocomplete;

})));

});

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function getVariableAutocompleteItems(plugin) {
    if (0 === autocomplete_items.length) {
        plugin.getVariables().forEach((variable) => {
            autocomplete_items.push(...variable.getAutocompleteItems());
        });
    }
    return autocomplete_items;
}
function resetVariableAutocompleteItems() {
    while (autocomplete_items.length) {
        autocomplete_items.pop();
    }
}
const autocomplete_items = [];

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 *
 * @param plugin Used for getting a list of Variable autocomplete items.
 * @param input_element
 * @param call_on_completion A function that will be called when a user has selected a suggestion and performed the autocomplete action. onChange event will not be called, because it would trigger opening the autocomplete menu again, so that's why a separate callback is used.
 * @param extra_autocomplete_items
 */
function createAutocomplete(plugin, input_element, call_on_completion, extra_autocomplete_items = []) {
    const autocompleteMenu = autocomplete({
        input: input_element,
        fetch: (input_value_but_not_used, update) => {
            const autocomplete_items = merge_and_sort_autocomplete_items(getVariableAutocompleteItems(plugin), CustomAutocompleteItems, extra_autocomplete_items);
            const max_suggestions = 30;
            // Get the so far typed text - exclude everything that is on the right side of the caret.
            const caret_position = input_element.selectionStart;
            if (null === caret_position) {
                throw new Error("createAutocomplete(): fetch(): caret_position is null.");
            }
            const typed_text = input_element.value.slice(0, caret_position);
            const search_query = get_search_query(typed_text);
            if ("" === search_query.search_text) {
                // No suggestions for empty word.
                update([]);
            }
            else {
                // The word is not empty, so can suggest something.
                let matched_items = autocomplete_items.filter(item => item_match(item, search_query));
                sort_autocomplete_items(matched_items, search_query);
                matched_items = matched_items.slice(0, max_suggestions); // Limit to a reasonable amount of suggestions.
                update(matched_items);
            }
        },
        onSelect: (item) => {
            // A user has selected an item to be autocompleted
            // Get the item text and already typed text
            let supplement = item.value;
            let caret_position = input_element.selectionStart;
            if (null === caret_position) {
                throw new Error("createAutocomplete(): fetch(): caret_position is null.");
            }
            const typed_text = input_element.value.slice(0, caret_position);
            const search_query = get_search_query(typed_text);
            const search_text = search_query.search_text;
            // Special case: Check if }} happens to appear after the caret
            const after_caret = input_element.value.slice(caret_position, caret_position + 2);
            if ("}}" === after_caret) {
                // The replacing will happen in a {{variable}}.
                // Do not accidentally insert another }} pair.
                supplement = supplement.replace(/\}\}$/u, ""); // Only removes a trailing }} if there is one.
            }
            // Try to save part of the beginning, in case it seems like not being part of the search query.
            let replace_start = find_starting_position(search_text, supplement); // The length difference of typed_text and search_text will be added here below.
            if (false === replace_start) {
                // This should never happen, but if it does, do not replace anything, just insert.
                replace_start = caret_position;
            }
            else {
                // Adjust the position
                replace_start += typed_text.length - search_text.length;
            }
            // Choose a method for doing the inserting
            if (undefined !== document.execCommand) {
                // execCommand() is deprecated, but available.
                // Use it to do the insertion, because this way an undo history can be preserved.
                input_element.setSelectionRange(replace_start, caret_position); // First select the part that will be replaced, because execCommand() does not support defining positions. This adds a cumbersome selection step to the undo history, but at least undoing works.
                document.execCommand("insertText", false, supplement);
            }
            else {
                // execCommand() is not available anymore.
                // Use setRangeText() to do the insertion. It will clear undo history, but at least the insertion works.
                input_element.setRangeText(supplement, replace_start, caret_position);
            }
            // Move the caret to a logical continuation point
            caret_position = replace_start + supplement.length;
            if (supplement.match(/:\}\}$/u)) {
                // Place the caret after the colon, instead of after }}.
                caret_position -= 2;
            }
            input_element.setSelectionRange(caret_position, caret_position);
            // Call a hook
            call_on_completion(input_element.value);
        },
        render: (item) => {
            const div_element = document.createElement("div");
            div_element.createSpan({ text: item.value, attr: { class: "SC-autocomplete-value" } });
            if (item.help_text) {
                div_element.createSpan({ text: ": ", attr: { class: "SC-autocomplete-separator" } });
                div_element.createSpan({ attr: { class: "SC-autocomplete-help-text" } }).insertAdjacentHTML("beforeend", item.help_text);
            }
            // Documentation link
            const documentationLink = item.documentationLink;
            if (undefined !== documentationLink) {
                const documentationLinkElement = div_element.createEl("a", { attr: { "title": "Documentation: " + item.value } }); // Use "title" instead of "aria-label", because I don't know how to make "aria-label" show a tooltip box on a custom element.
                obsidian.setIcon(documentationLinkElement, "help");
                documentationLinkElement.addClass("SC-autocomplete-link-icon");
                documentationLinkElement.onClickEvent((event) => {
                    gotoURL(documentationLink);
                    // event.preventDefault(); Not needed, I guess.
                    event.stopImmediatePropagation(); // Do not close the autocomplete menu.
                });
            }
            return div_element;
        },
        minLength: 2,
        className: "SC-autocomplete",
        keysToIgnore: [38 /* Up */, 13 /* Enter */, 27 /* Esc */, 16 /* Shift */, 17 /* Ctrl */, 18 /* Alt */, 20 /* CapsLock */, 91 /* WindowsKey */, 9 /* Tab */],
        preventSubmit: true, // Prevents creating newlines in textareas when enter is pressed in the autocomplete menu.
    });
    // Make the plugin able to close the menu if the plugin is disabled (or restarted).
    plugin.registerAutocompleteMenu(autocompleteMenu);
}
function item_match(item, search_query) {
    const item_value = item.value.toLocaleLowerCase();
    const search_text = search_query.search_text.toLocaleLowerCase();
    // Match query type
    if (item.type !== search_query.search_type) {
        // If the query type is different, do not include this item.
        // This can happen e.g. if {{ is typed, and the item is not a variable, or {{! is typed, and the item is not an unescaped variable.
        return false;
    }
    // Match text
    let search_character;
    let search_position = 0;
    for (let search_character_index = 0; search_character_index < search_text.length; search_character_index++) {
        search_character = search_text[search_character_index];
        if (item_value.includes(search_character, search_position)) {
            // This character was found in item_value.
            search_position = item_value.indexOf(search_character, search_position) + 1;
        }
        else {
            // This character was not found.
            return false;
        }
    }
    return true;
}
function find_starting_position(typed_text, supplement) {
    typed_text = typed_text.toLocaleLowerCase();
    supplement = supplement.toLocaleLowerCase();
    for (let supplement_index = supplement.length; supplement_index >= 0; supplement_index--) {
        const partial_supplement = supplement.slice(0, supplement_index);
        if (typed_text.contains(partial_supplement)) {
            return typed_text.indexOf(partial_supplement);
        }
    }
    return false;
}
/**
 * Sorts in place, does not make a copy.
 * @param autocomplete_items
 * @param search_query
 */
function sort_autocomplete_items(autocomplete_items, search_query) {
    const search_text_excluding_curly_brackets = search_query.search_text.replace(/^{{!?/, "");
    function get_common_beginning_length(autocomplete_item, search_query) {
        const search_text = search_query.search_text.toLocaleLowerCase();
        const item_value = autocomplete_item.value.toLocaleLowerCase();
        const shortest_length = Math.min(search_text.length, item_value.length);
        for (let character_index = 0; character_index < shortest_length; character_index++) {
            const search_character = search_text[character_index];
            const item_character = item_value[character_index];
            if (search_character !== item_character) {
                // The common beginning has ended.
                return character_index;
            }
        }
        return shortest_length;
    }
    autocomplete_items.sort((a, b) => {
        const boost_a = Math.max(get_common_beginning_length(a, search_query), 1); // Boosts are used as multipliers,
        const boost_b = Math.max(get_common_beginning_length(b, search_query), 1); // so they cannot be zero.
        const a_length = a.value.length * boost_b; // boost_b worsens A (= makes it artificially "longer")
        const b_length = b.value.length * boost_a; // boost_a worsens B
        // Determine sorting method. If the search query is just a couple of characters, the matches would be quite vague, sorting by the matched items' length would not tell much, and the list would just look strangely ordered.
        if (search_text_excluding_curly_brackets.length < 2 || a_length === b_length) {
            // Sort alphabetically.
            return a.value > b.value ? 1 : -1;
        }
        else {
            // Sort by lengths. The shortest item is preferred. If an item has a long common beginning with the search query, boost the item up.
            return a_length - b_length;
        }
    });
}
const CustomAutocompleteItems = [];
function addCustomAutocompleteItems(custom_autocomplete_yaml) {
    // Ensure the content is not empty
    if (0 === custom_autocomplete_yaml.trim().length) {
        return "The content is empty.";
    }
    // Try to parse YAML syntax
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    let yaml; // 'any' is defined in obsidian.d.ts for the return type of parseYaml(), so I made ESLint ignore it.
    try {
        yaml = obsidian.parseYaml(custom_autocomplete_yaml);
    }
    catch (error) {
        // A syntax error has appeared.
        return error.message;
    }
    if (null === yaml || typeof yaml !== "object") {
        return "Unable to parse the content due to unknown reason.";
    }
    // Iterate autocomplete item groups
    const group_names = Object.getOwnPropertyNames(yaml);
    const error_messages = [];
    group_names.forEach((group_name) => {
        const group_items = yaml[group_name];
        const group_item_values = Object.getOwnPropertyNames(group_items);
        // Iterate all autocomplete items in the group
        group_item_values.forEach((autocomplete_item_value) => {
            const autocomplete_item_label = group_items[autocomplete_item_value];
            if (typeof autocomplete_item_label !== "string") {
                error_messages.push("Autocomplete item '" + autocomplete_item_value + "' has an incorrect help text type: " + autocomplete_item_label + " is a " + typeof autocomplete_item_label + ", but it should be a string.");
                return;
            }
            // Determine a correct type for the item
            let type = "other";
            if (autocomplete_item_value.startsWith("{{")) {
                // This is a variable
                type = "normal-variable";
            }
            // The item is ok, add it to the list
            CustomAutocompleteItems.push({
                value: autocomplete_item_value,
                help_text: autocomplete_item_label,
                group: group_name,
                type: type,
            });
            if (type === "normal-variable") {
                // Add an unescaped version of the variable, too
                CustomAutocompleteItems.push({
                    value: autocomplete_item_value.replace(/^\{\{/u, "{{!"),
                    help_text: autocomplete_item_label,
                    group: group_name,
                    type: "unescaped-variable",
                });
            }
        });
    });
    if (error_messages.length > 0) {
        // Something failed
        return error_messages.join("; ");
    }
    // All ok
    return true;
}
/**
 * TODO: Can the sorting be removed from here? Now autocomplete items are sorted again every time when filtering, based on the keyword (https://github.com/Taitava/obsidian-shellcommands/issues/249).
 * @param autocomplete_item_sets
 */
function merge_and_sort_autocomplete_items(...autocomplete_item_sets) {
    const merged_autocomplete_items = (new Array()).concat(...autocomplete_item_sets);
    return merged_autocomplete_items.sort((a, b) => {
        // First compare groups
        if (a.group < b.group) {
            // a's group should come before b's group.
            return -1;
        }
        else if (a.group > b.group) {
            // a's group should come after b's group.
            return 1;
        }
        else {
            // The groups are the same.
            // Compare values.
            if (a.value < b.value) {
                // a should come before b.
                return -1;
            }
            else if (a.value > b.value) {
                // a should come after b.
                return 1;
            }
            else {
                // The values are the same.
                // The order does not matter.
                return 0;
            }
        }
    });
}
/**
 * Reduces an input string to the nearest logical word.
 * @param typed_text
 */
function get_search_query(typed_text) {
    const searchTextMatchArray = typed_text.match(/\S*?$/u); // An array, but only one match is expected.
    if (null === searchTextMatchArray) {
        throw new Error("get_search_query(): Regex match failed.");
    }
    let search_text = searchTextMatchArray[0]; // Reduce the text - limit to a single word (= exclude spaces and everything before them).
    let search_type = "other"; // May be overwritten.
    if (search_text.contains("}}")) {
        // The query happens right after a {{variable}}.
        // Make the query string to start after the }} pair, i.e. remove }} and everything before it. This improves the search.
        search_text = search_text.replace(/.+\}\}/u, "");
    }
    if (search_text.contains("{{")) {
        // A {{variable}} is being queried.
        // Make the query string to start from the {{ pair, i.e. remove everything before {{ . This improves the search.
        search_text = search_text.replace(/.+\{\{/u, "{{");
        if (search_text.contains("{{!")) {
            // An _unescaped_ variable is searched for.
            search_type = "unescaped-variable";
        }
        else {
            // A normal variable is searched for.
            search_type = "normal-variable";
        }
    }
    return {
        search_text: search_text,
        search_type: search_type,
    };
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputWrapperSettingsModal extends SC_Modal {
    constructor(plugin, output_wrapper, 
    /** Can be undefined if the output wrapper is created from a place where there is no name element. */
    output_wrapper_name_setting, 
    /** If defined, a button will be added and on_after_approval() / on_after_cancelling() will be called depending on whether the button was clicked or not. */
    ok_button_text, on_after_approval, on_after_cancelling) {
        super(plugin);
        this.output_wrapper = output_wrapper;
        this.output_wrapper_name_setting = output_wrapper_name_setting;
        this.ok_button_text = ok_button_text;
        this.on_after_approval = on_after_approval;
        this.on_after_cancelling = on_after_cancelling;
        this.approved = false;
    }
    onOpen() {
        super.onOpen();
        const container_element = this.modalEl.createDiv();
        container_element.addClass("SC-setting-group"); // Make setting fields wider in this container.
        // Title
        const title_setting = new obsidian.Setting(container_element)
            .setName("Output wrapper title")
            .setDesc("Only used in settings, will not appear in output.")
            .addText(text => text
            .setValue(this.output_wrapper.getTitle())
            .onChange(async (new_title) => {
            this.output_wrapper.getConfiguration().title = new_title;
            await this.plugin.saveSettings();
            // Update the title in a name setting. (Only if the modal was created from a place where an OutputWrapper name element exists).
            this.output_wrapper_name_setting?.setName(new_title);
        }));
        const title_input_element = title_setting.controlEl.find("input");
        // Content
        const output_variable = new Variable_Output(this.plugin, ""); // For getting an autocomplete item.
        new obsidian.Setting(container_element)
            .setName("Content")
            .setDesc("Use {{output}} as a placeholder for text that will be received from a shell command. Other variables are available, too.")
            .addTextArea(textarea_component => textarea_component
            .setValue(this.output_wrapper.configuration.content)
            .onChange(async (new_content) => {
            this.output_wrapper.configuration.content = new_content;
            await this.plugin.saveSettings();
        })
            .then((textarea_component) => {
            // Autocomplete for Content.
            if (this.plugin.settings.show_autocomplete_menu) {
                createAutocomplete(this.plugin, textarea_component.inputEl, () => textarea_component.onChanged(), output_variable.getAutocompleteItems());
            }
        }));
        // Focus on the title field.
        title_input_element.focus();
        // Ok button
        const okButtonText = this.ok_button_text;
        if (okButtonText) {
            new obsidian.Setting(container_element)
                .addButton(button => button
                .setButtonText(okButtonText)
                .onClick(() => this.approve()));
        }
    }
    approve() {
        if (this.on_after_approval) {
            this.approved = true;
            this.on_after_approval();
        }
        this.close();
    }
    onClose() {
        super.onClose();
        // Call a cancelling hook if one is defined (and if the closing happens due to cancelling, i.e. the ok button is NOT clicked).
        if (!this.approved && this.on_after_cancelling) {
            this.on_after_cancelling();
        }
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class OutputWrapperModel extends Model {
    constructor() {
        super(...arguments);
        this.output_wrappers = new OutputWrapperMap();
    }
    _createSettingFields(output_wrapper, container_element) {
        debugLog("Creating setting fields for an OutputWrapper instance.");
        const output_wrapper_name_setting = new obsidian.Setting(container_element)
            // Configuration button
            .setName(output_wrapper.getTitle())
            .addExtraButton(button => button
            .setTooltip("Define output wrapper content")
            .setIcon("gear")
            .onClick(() => {
            this.openSettingsModal(output_wrapper, output_wrapper_name_setting);
        }));
        return output_wrapper_name_setting;
    }
    defineParentConfigurationRelation(output_wrapper) {
        return {
            type: "one-to-many-id",
            key: "output_wrappers",
            id: output_wrapper.getID(),
        };
    }
    getSingularName() {
        return "Output wrapper";
    }
    loadInstances(parent_configuration) {
        debugLog("Loading OutputWrapper instances.");
        this.output_wrappers = new OutputWrapperMap();
        parent_configuration.output_wrappers.forEach((output_wrapper_configuration) => {
            const output_wrapper = new OutputWrapper(this, this.plugin, output_wrapper_configuration, parent_configuration);
            this.output_wrappers.set(output_wrapper_configuration.id, output_wrapper);
        });
        return this.output_wrappers;
    }
    newInstance(parent_configuration) {
        debugLog("Creating a new OutputWrapper instance.");
        // TODO: Move this logic to the base Model class.
        // Setup a default configuration and generate an ID
        const output_wrapper_configuration = this.getDefaultConfiguration();
        // Instantiate an OutputWrapper
        const output_wrapper = new OutputWrapper(this, this.plugin, output_wrapper_configuration, this.plugin.settings);
        this.output_wrappers.set(output_wrapper.getID(), output_wrapper);
        // Store the configuration into plugin's settings
        parent_configuration.output_wrappers.push(output_wrapper_configuration);
        // Return the OutputWrapper
        return output_wrapper;
    }
    validateValue(output_wrapper, field, value) {
        // No validation is needed, I guess. 'Title' and 'content' can both be empty, although an empty title does not make sense.
        return Promise.resolve(undefined);
    }
    openSettingsModal(output_wrapper, output_wrapper_name_setting) {
        debugLog("Opening settings modal for an OutputWrapper instance.");
        const modal = new OutputWrapperSettingsModal(this.plugin, output_wrapper, output_wrapper_name_setting);
        modal.open();
    }
    getDefaultConfiguration() {
        return {
            id: getIDGenerator().generateID(),
            title: "",
            content: "",
        };
    }
    _deleteInstance(deletable_output_wrapper) {
        debugLog("Deleting an OutputWrapper instance.");
        // Remove the OutputWrapper from all TShellCommands that use it.
        const shell_commands = this.plugin.getTShellCommands();
        for (const shell_command_id in shell_commands) {
            const t_shell_command = shell_commands[shell_command_id];
            const output_wrappers = t_shell_command.getConfiguration().output_wrappers;
            Object.each(output_wrappers, (output_wrapper_id, output_stream) => {
                if (output_wrapper_id === deletable_output_wrapper.getID()) {
                    // A shell command uses the output wrapper that is about to be deleted.
                    // Configure the shell command not to use any output wrapper.
                    output_wrappers[output_stream] = null;
                }
            });
        }
        // Remove the OutputWrapper from this class's internal list.
        this.output_wrappers.delete(deletable_output_wrapper.getID());
    }
}
class OutputWrapperMap extends Map {
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function introduceModels(plugin) {
    debugLog("Introducing models.");
    // Keep in alphabetical order, if possible.
    introduceModelClass(new CustomVariableModel(plugin));
    introduceModelClass(new PromptFieldModel(plugin));
    introduceModelClass(new PromptModel(plugin));
    introduceModelClass(new OutputWrapperModel(plugin));
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * This class serves as the actual operational variable class for custom variables. It's paired with the CustomVariableInstance class, which acts
 * as a configuration class to handle settings together with CustomVariableModel class.
 */
class CustomVariable extends Variable {
    constructor(plugin, custom_variable_instance) {
        super(plugin);
        this.custom_variable_instance = custom_variable_instance;
        this.value = null; // TODO: When implementing variable types, make this class abstract and let subclasses define the type of this property.
        this.always_available = false;
        this.on_change_callbacks = new Set();
        this.updateProperties();
        debugLog(`Loaded CustomVariable ${this.variable_name}.`);
    }
    async generateValue() {
        if (null === this.value) {
            debugLog(`Custom variable ${this.variable_name} does not have a value yet, and no default value is defined.`);
            this.throw("This custom variable does not have a value yet, and no default value is defined.");
        }
        return this.value;
    }
    /**
     * TODO: Make it possible to prevent calling onChange callbacks:
     *  - Make it possible to call the callbacks later outside this class.
     *  - This makes it possible to prevent unnecessary CustomVariableView updates when multiple CustomVariables are assigned values in one go (via Shell command URI).
     *  - Store the old value into some kind of history list.
     *  - When calling the callbacks, the current CustomVariable should be passed as a parameter instead of the 'value' and 'old_value' parameters (which can be accessed via the CustomVariable object).
     *
     * @param value
     */
    async setValue(value) {
        const old_value = this.value;
        debugLog(`CustomVariable ${this.variable_name}: Setting value to: ${value} (old was: ${old_value}).`);
        this.value = value;
        // Call the onChange hook.
        await this.callOnChangeCallbacks(value, old_value ?? ""); // Use "" if old_value is null.
    }
    /**
     * Retrieves variable_name and help_text properties from the associated CustomVariableInstance.
     * Called when loading the CustomVariable and when the associated CustomVariableInstance's settings are changed.
     */
    updateProperties() {
        debugLog(`CustomVariable ${this.variable_name}: Updating variable name and help text.`);
        this.variable_name = this.custom_variable_instance.getPrefixedName();
        this.help_text = this.custom_variable_instance.configuration.description;
        resetVariableAutocompleteItems(); // Make autocomplete lists reload their content in order to get the new variable name/help text.
    }
    getIdentifier() {
        return this.custom_variable_instance.getID();
    }
    /**
     * Adds the given callback function to a stack of functions that will be called whenever this CustomVariable's value changes.
     * @param on_change_callback
     */
    onChange(on_change_callback) {
        this.on_change_callbacks.add(on_change_callback);
    }
    async callOnChangeCallbacks(new_value, old_value) {
        debugLog(`CustomVariable ${this.variable_name}: Calling onChange callbacks.`);
        for (const on_change_callback of this.on_change_callbacks) {
            await on_change_callback(this, new_value, old_value);
        }
    }
    getConfiguration() {
        return this.custom_variable_instance.configuration;
    }
    getGlobalDefaultValueConfiguration() {
        return this.custom_variable_instance.configuration.default_value;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * This class serves as an accessor to CustomVariable configurations. It's paired with the CustomVariable class, which acts
 * as an operational class to implement the variable functionality.
 *
 * TODO: Decide a better name for this class. It's too easy to confuse with the CustomVariable class name.
 */
class CustomVariableInstance extends Instance {
    constructor(model, configuration, parent_configuration) {
        super(model, configuration, parent_configuration);
        this.model = model;
        this.custom_variable = null;
        // Introduce the ID to an ID generator so that it won't accidentally generate the same ID again when creating new CustomVariableInstances.
        getIDGenerator().addReservedID(configuration.id);
        debugLog(`Loaded CustomVariableInstance ${this.getID()}.`);
    }
    getID() {
        return this.configuration.id;
    }
    getFullName() {
        return `{{${this.getPrefixedName()}}}`;
    }
    /**
     * Adds an underscore in front of the name.
     */
    getPrefixedName() {
        return "_" + this.configuration.name;
    }
    getTitle() {
        return this.getFullName();
    }
    getCustomVariable() {
        if (!this.custom_variable) {
            debugLog(`CustomVariableInstance ${this.getID()}: Cannot find a CustomVariable. Maybe it's not loaded?`);
            throw new Error(this.constructor.name + ".getVariable(): Cannot find a CustomVariable. Maybe it's not loaded?");
        }
        return this.custom_variable;
    }
    createCustomVariable() {
        debugLog(`CustomVariableInstance ${this.getID()}: Creating an operational CustomVariable.`);
        this.custom_variable = new CustomVariable(this.model.plugin, this);
        this.custom_variable.onChange(async () => await this.model.plugin.updateCustomVariableViews());
        return this.custom_variable;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_onLayoutReady extends SC_Event {
    constructor() {
        super(...arguments);
        this.register_after_changing_settings = false;
    }
    _register(t_shell_command) {
        this.app.workspace.onLayoutReady(async () => await this.trigger(t_shell_command));
        return false; // The base class does not need to register anything.
    }
    _unregister(t_shell_command) {
        // No need to unregister, because this event happens only once when Obsidian starts. If the event is not enabled for a shell command, next time Obsidian starts, this event won't get registered.
    }
}
SC_Event_onLayoutReady.event_code = "on-layout-ready";
SC_Event_onLayoutReady.event_title = "Obsidian starts";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_onQuit extends SC_WorkspaceEvent {
    constructor() {
        super(...arguments);
        this.workspace_event = "quit";
    }
}
SC_Event_onQuit.event_code = "on-quit";
SC_Event_onQuit.event_title = "Obsidian quits";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_onActiveLeafChanged extends SC_WorkspaceEvent {
    constructor() {
        super(...arguments);
        this.workspace_event = "active-leaf-change";
    }
}
SC_Event_onActiveLeafChanged.event_code = "on-active-leaf-changed";
SC_Event_onActiveLeafChanged.event_title = "Switching the active pane";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_EveryNSeconds extends SC_Event {
    constructor() {
        super(...arguments);
        this.default_configuration = {
            enabled: false,
            seconds: 60,
        };
        this.intervals_ids = {};
    }
    _register(t_shell_command) {
        const milliseconds = this.getConfiguration(t_shell_command).seconds * 1000;
        const interval_id = window.setInterval(async () => await this.trigger(t_shell_command), milliseconds);
        this.plugin.registerInterval(interval_id);
        this.intervals_ids[t_shell_command.getId()] = interval_id;
        return false; // The base class does not need to register anything.
    }
    _unregister(t_shell_command) {
        window.clearInterval(this.intervals_ids[t_shell_command.getId()]);
    }
    /**
     * Overridden only to change the return type.
     * @param t_shell_command
     * @protected
     */
    getConfiguration(t_shell_command) {
        return super.getConfiguration(t_shell_command);
    }
    createExtraSettingsFields(extra_settings_container, t_shell_command) {
        const configuration = this.getConfiguration(t_shell_command);
        let apply_seconds;
        new obsidian.Setting(extra_settings_container)
            .setName("Seconds")
            .setDesc("Needs to be at least 1. Currently supports only integers.")
            .addText(text => text
            .setValue(configuration.seconds.toString())
            .onChange((raw_value) => {
            apply_seconds = parseInt(raw_value);
            // Don't save here, because the user might still be editing the number.
        }))
            .addButton(button => button
            .setButtonText("Apply")
            .onClick(async () => {
            if (undefined == apply_seconds || apply_seconds === this.getConfiguration(t_shell_command).seconds) {
                new obsidian.Notice("You didn't change the seconds!");
            }
            else if (isNaN(apply_seconds)) {
                new obsidian.Notice("The seconds need to be an integer!");
            }
            else if (apply_seconds <= 0) {
                new obsidian.Notice("The seconds need to be at least 1!");
            }
            else {
                // All ok, save.
                this.getConfiguration(t_shell_command).seconds = apply_seconds;
                await this.plugin.saveSettings();
                // Re-register to apply the change
                this.unregister(t_shell_command);
                this.register(t_shell_command);
                // Done
                this.noticeAboutEnabling(t_shell_command);
            }
        }));
    }
    onAfterEnabling(t_shell_command) {
        this.noticeAboutEnabling(t_shell_command);
    }
    noticeAboutEnabling(t_shell_command) {
        new obsidian.Notice("The shell command will run every " + this.getConfiguration(t_shell_command).seconds + " seconds");
    }
}
SC_Event_EveryNSeconds.event_code = "every-n-seconds";
SC_Event_EveryNSeconds.event_title = "Every n seconds";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Event_EditorMenu extends SC_MenuEvent {
    constructor() {
        super(...arguments);
        this.workspace_event = "editor-menu";
    }
    getTrigger(t_shell_command) {
        return async (menu, editor, view) => {
            await this.addTShellCommandToMenu(t_shell_command, menu);
        };
    }
}
SC_Event_EditorMenu.event_code = "editor-menu";
SC_Event_EditorMenu.event_title = "Editor menu";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function getSC_Events(plugin) {
    if (eventList.length === 0) {
        // Cache the list of SC_Event objects
        eventList.push(new SC_Event_onLayoutReady(plugin), new SC_Event_onQuit(plugin), new SC_Event_onActiveLeafChanged(plugin), new SC_Event_EveryNSeconds(plugin), new SC_Event_FileMenu(plugin), new SC_Event_FolderMenu(plugin), new SC_Event_EditorMenu(plugin), new SC_Event_FileContentModified(plugin), new SC_Event_FileCreated(plugin), new SC_Event_FileDeleted(plugin), new SC_Event_FileMoved(plugin), new SC_Event_FileRenamed(plugin), new SC_Event_FolderCreated(plugin), new SC_Event_FolderDeleted(plugin), new SC_Event_FolderMoved(plugin), new SC_Event_FolderRenamed(plugin));
    }
    return eventList;
}
const eventList = [];

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * A wrapper for Obsidian's setIcon(), but with the difference that this one does not need a container as a parameter.
 */
function getIconHTML(icon_id) {
    if (!icon_id) {
        return "";
    }
    const icon_container = document.body.createEl("div"); // A temporary element, will be deleted soon. Not nice to create a temporary element in the body, but I don't know any better way.
    obsidian.setIcon(icon_container, icon_id);
    const icon_html = icon_container.innerHTML;
    icon_container.remove();
    return icon_html;
}
/**
 * @author The list is provided by phibr0.
 * @link https://discord.com/channels/686053708261228577/840286264964022302/968248588641665075
 * @description phibr0: "Updated Icon List for Obsidian v0.14.7+ (lucide icons v0.30.0 + obsidians own)"
 * @copyright The copyright statement at the top of this file does not affect this list of icons.
 * TODO: The list seems to miss some icons, at least 'gear'.
 */
const ICON_LIST = ["activity", "airplay", "alarm-check", "alarm-clock-off", "alarm-clock", "alarm-minus", "alarm-plus", "album", "alert-circle", "alert-octagon", "alert-triangle", "align-center-horizontal", "align-center-vertical", "align-center", "align-end-horizontal", "align-end-vertical", "align-horizontal-distribute-center", "align-horizontal-distribute-end", "align-horizontal-distribute-start", "align-horizontal-justify-center", "align-horizontal-justify-end", "align-horizontal-justify-start", "align-horizontal-space-around", "align-horizontal-space-between", "align-justify", "align-left", "align-right", "align-start-horizontal", "align-start-vertical", "align-vertical-distribute-center", "align-vertical-distribute-end", "align-vertical-distribute-start", "align-vertical-justify-center", "align-vertical-justify-end", "align-vertical-justify-start", "align-vertical-space-around", "align-vertical-space-between", "anchor", "aperture", "archive", "arrow-big-down", "arrow-big-left", "arrow-big-right", "arrow-big-up", "arrow-down-circle", "arrow-down-left", "arrow-down-right", "arrow-down", "arrow-left-circle", "arrow-left-right", "arrow-left", "arrow-right-circle", "arrow-right", "arrow-up-circle", "arrow-up-left", "arrow-up-right", "arrow-up", "asterisk", "at-sign", "award", "axe", "banknote", "bar-chart-2", "bar-chart", "baseline", "battery-charging", "battery-full", "battery-low", "battery-medium", "battery", "beaker", "bell-minus", "bell-off", "bell-plus", "bell-ring", "bell", "bike", "binary", "bitcoin", "bluetooth-connected", "bluetooth-off", "bluetooth-searching", "bluetooth", "bold", "book-open", "book", "bookmark-minus", "bookmark-plus", "bookmark", "bot", "box-select", "box", "briefcase", "brush", "bug", "building-2", "building", "bus", "calculator", "calendar", "camera-off", "camera", "car", "carrot", "cast", "check-circle-2", "check-circle", "check-square", "check", "chevron-down", "chevron-first", "chevron-last", "chevron-left", "chevron-right", "chevron-up", "chevrons-down-up", "chevrons-down", "chevrons-left", "chevrons-right", "chevrons-up-down", "chevrons-up", "chrome", "circle-slashed", "circle", "clipboard-check", "clipboard-copy", "clipboard-list", "clipboard-x", "clipboard", "clock-1", "clock-10", "clock-11", "clock-12", "clock-2", "clock-3", "clock-4", "clock-5", "clock-6", "clock-7", "clock-8", "clock-9", "clock", "cloud-drizzle", "cloud-fog", "cloud-hail", "cloud-lightning", "cloud-moon", "cloud-off", "cloud-rain-wind", "cloud-rain", "cloud-snow", "cloud-sun", "cloud", "cloudy", "clover", "code-2", "code", "codepen", "codesandbox", "coffee", "coins", "columns", "command", "compass", "contact", "contrast", "cookie", "copy", "copyleft", "copyright", "corner-down-left", "corner-down-right", "corner-left-down", "corner-left-up", "corner-right-down", "corner-right-up", "corner-up-left", "corner-up-right", "cpu", "credit-card", "crop", "cross", "crosshair", "crown", "currency", "database", "delete", "dice-1", "dice-2", "dice-3", "dice-4", "dice-5", "dice-6", "disc", "divide-circle", "divide-square", "divide", "dollar-sign", "download-cloud", "download", "dribbble", "droplet", "droplets", "drumstick", "edit-2", "edit-3", "edit", "egg", "equal-not", "equal", "eraser", "euro", "expand", "external-link", "eye-off", "eye", "facebook", "fast-forward", "feather", "figma", "file-check-2", "file-check", "file-code", "file-digit", "file-input", "file-minus-2", "file-minus", "file-output", "file-plus-2", "file-plus", "file-search", "file-text", "file-x-2", "file-x", "file", "files", "film", "filter", "flag-off", "flag-triangle-left", "flag-triangle-right", "flag", "flame", "flashlight-off", "flashlight", "flask-conical", "flask-round", "folder-minus", "folder-open", "folder-plus", "folder", "form-input", "forward", "frame", "framer", "frown", "function-square", "gamepad-2", "gamepad", "gauge", "gavel", "gem", "ghost", "gift", "git-branch-plus", "git-branch", "git-commit", "git-fork", "git-merge", "git-pull-request", "github", "gitlab", "glasses", "globe-2", "globe", "grab", "graduation-cap", "grid", "grip-horizontal", "grip-vertical", "hammer", "hand-metal", "hand", "hard-drive", "hard-hat", "hash", "haze", "headphones", "heart", "help-circle", "hexagon", "highlighter", "history", "home", "image-minus", "image-off", "image-plus", "image", "import", "inbox", "indent", "indian-rupee", "infinity", "info", "inspect", "instagram", "italic", "japanese-yen", "key", "keyboard", "landmark", "languages", "laptop-2", "laptop", "lasso-select", "lasso", "layers", "layout-dashboard", "layout-grid", "layout-list", "layout-template", "layout", "library", "life-buoy", "lightbulb-off", "lightbulb", "link-2-off", "link-2", "link", "linkedin", "list-checks", "list-minus", "list-ordered", "list-plus", "list-x", "list", "loader-2", "loader", "locate-fixed", "locate-off", "locate", "lock", "log-in", "log-out", "mail", "map-pin", "map", "maximize-2", "maximize", "megaphone", "meh", "menu", "message-circle", "message-square", "mic-off", "mic", "minimize-2", "minimize", "minus-circle", "minus-square", "minus", "monitor-off", "monitor-speaker", "monitor", "moon", "more-horizontal", "more-vertical", "mountain-snow", "mountain", "mouse-pointer-2", "mouse-pointer-click", "mouse-pointer", "mouse", "move-diagonal-2", "move-diagonal", "move-horizontal", "move-vertical", "move", "music", "navigation-2", "navigation", "network", "octagon", "option", "outdent", "package-check", "package-minus", "package-plus", "package-search", "package-x", "package", "palette", "palmtree", "paperclip", "pause-circle", "pause-octagon", "pause", "pen-tool", "pencil", "percent", "person-standing", "phone-call", "phone-forwarded", "phone-incoming", "phone-missed", "phone-off", "phone-outgoing", "phone", "pie-chart", "piggy-bank", "pin", "pipette", "plane", "play-circle", "play", "plug-zap", "plus-circle", "plus-square", "plus", "pocket", "podcast", "pointer", "pound-sterling", "power-off", "power", "printer", "qr-code", "quote", "radio-receiver", "radio", "redo", "refresh-ccw", "refresh-cw", "regex", "repeat-1", "repeat", "reply-all", "reply", "rewind", "rocket", "rocking-chair", "rotate-ccw", "rotate-cw", "rss", "ruler", "russian-ruble", "save", "scale", "scan-line", "scan", "scissors", "screen-share-off", "screen-share", "search", "send", "separator-horizontal", "separator-vertical", "server-crash", "server-off", "server", "settings-2", "settings", "share-2", "share", "sheet", "shield-alert", "shield-check", "shield-close", "shield-off", "shield", "shirt", "shopping-bag", "shopping-cart", "shovel", "shrink", "shuffle", "sidebar-close", "sidebar-open", "sidebar", "sigma", "signal-high", "signal-low", "signal-medium", "signal-zero", "signal", "skip-back", "skip-forward", "skull", "slack", "slash", "sliders", "smartphone-charging", "smartphone", "smile", "snowflake", "sort-asc", "sort-desc", "speaker", "sprout", "square", "star-half", "star", "stop-circle", "stretch-horizontal", "stretch-vertical", "strikethrough", "subscript", "sun", "sunrise", "sunset", "superscript", "swiss-franc", "switch-camera", "table", "tablet", "tag", "target", "tent", "terminal-square", "terminal", "text-cursor-input", "text-cursor", "thermometer-snowflake", "thermometer-sun", "thermometer", "thumbs-down", "thumbs-up", "ticket", "timer-off", "timer-reset", "timer", "toggle-left", "toggle-right", "tornado", "trash-2", "trash", "trello", "trending-down", "trending-up", "triangle", "truck", "tv-2", "tv", "twitch", "twitter", "type", "umbrella", "underline", "undo", "unlink-2", "unlink", "unlock", "upload-cloud", "upload", "user-check", "user-minus", "user-plus", "user-x", "user", "users", "verified", "vibrate", "video-off", "video", "view", "voicemail", "volume-1", "volume-2", "volume-x", "volume", "wallet", "wand", "watch", "waves", "webcam", "wifi-off", "wifi", "wind", "wrap-text", "wrench", "x-circle", "x-octagon", "x-square", "x", "youtube", "zap-off", "zap", "zoom-in", "zoom-out", "search-large", "search", "activity", "airplay", "alarm-check", "alarm-clock-off", "alarm-clock", "alarm-minus", "alarm-plus", "album", "alert-circle", "alert-octagon", "alert-triangle", "align-center-horizontal", "align-center-vertical", "align-center", "align-end-horizontal", "align-end-vertical", "align-horizontal-distribute-center", "align-horizontal-distribute-end", "align-horizontal-distribute-start", "align-horizontal-justify-center", "align-horizontal-justify-end", "align-horizontal-justify-start", "align-horizontal-space-around", "align-horizontal-space-between", "align-justify", "align-left", "align-right", "align-start-horizontal", "align-start-vertical", "align-vertical-distribute-center", "align-vertical-distribute-end", "align-vertical-distribute-start", "align-vertical-justify-center", "align-vertical-justify-end", "align-vertical-justify-start", "align-vertical-space-around", "align-vertical-space-between", "anchor", "aperture", "archive", "arrow-big-down", "arrow-big-left", "arrow-big-right", "arrow-big-up", "arrow-down-circle", "arrow-down-left", "arrow-down-right", "arrow-down", "arrow-left-circle", "arrow-left-right", "arrow-left", "arrow-right-circle", "arrow-right", "arrow-up-circle", "arrow-up-left", "arrow-up-right", "arrow-up", "asterisk", "at-sign", "award", "axe", "banknote", "bar-chart-2", "bar-chart", "baseline", "battery-charging", "battery-full", "battery-low", "battery-medium", "battery", "beaker", "bell-minus", "bell-off", "bell-plus", "bell-ring", "bell", "bike", "binary", "bitcoin", "bluetooth-connected", "bluetooth-off", "bluetooth-searching", "bluetooth", "bold", "book-open", "book", "bookmark-minus", "bookmark-plus", "bookmark", "bot", "box-select", "box", "briefcase", "brush", "bug", "building-2", "building", "bus", "calculator", "calendar", "camera-off", "camera", "car", "carrot", "cast", "check-circle-2", "check-circle", "check-square", "check", "chevron-down", "chevron-first", "chevron-last", "chevron-left", "chevron-right", "chevron-up", "chevrons-down-up", "chevrons-down", "chevrons-left", "chevrons-right", "chevrons-up-down", "chevrons-up", "chrome", "circle-slashed", "circle", "clipboard-check", "clipboard-copy", "clipboard-list", "clipboard-x", "clipboard", "clock-1", "clock-10", "clock-11", "clock-12", "clock-2", "clock-3", "clock-4", "clock-5", "clock-6", "clock-7", "clock-8", "clock-9", "lucide-clock", "cloud-drizzle", "cloud-fog", "cloud-hail", "cloud-lightning", "cloud-moon", "cloud-off", "cloud-rain-wind", "cloud-rain", "cloud-snow", "cloud-sun", "lucide-cloud", "cloudy", "clover", "code-2", "code", "codepen", "codesandbox", "coffee", "coins", "columns", "command", "compass", "contact", "contrast", "cookie", "copy", "copyleft", "copyright", "corner-down-left", "corner-down-right", "corner-left-down", "corner-left-up", "corner-right-down", "corner-right-up", "corner-up-left", "corner-up-right", "cpu", "credit-card", "crop", "lucide-cross", "crosshair", "crown", "currency", "database", "delete", "dice-1", "dice-2", "dice-3", "dice-4", "dice-5", "dice-6", "disc", "divide-circle", "divide-square", "divide", "dollar-sign", "download-cloud", "download", "dribbble", "droplet", "droplets", "drumstick", "edit-2", "edit-3", "edit", "egg", "equal-not", "equal", "eraser", "euro", "expand", "external-link", "eye-off", "eye", "facebook", "fast-forward", "feather", "figma", "file-check-2", "file-check", "file-code", "file-digit", "file-input", "file-minus-2", "file-minus", "file-output", "file-plus-2", "file-plus", "file-search", "file-text", "file-x-2", "file-x", "file", "files", "film", "filter", "flag-off", "flag-triangle-left", "flag-triangle-right", "flag", "flame", "flashlight-off", "flashlight", "flask-conical", "flask-round", "folder-minus", "folder-open", "folder-plus", "lucide-folder", "form-input", "forward", "frame", "framer", "frown", "function-square", "gamepad-2", "gamepad", "gauge", "gavel", "gem", "ghost", "gift", "git-branch-plus", "git-branch", "git-commit", "git-fork", "git-merge", "git-pull-request", "github", "gitlab", "glasses", "globe-2", "globe", "grab", "graduation-cap", "grid", "grip-horizontal", "grip-vertical", "hammer", "hand-metal", "hand", "hard-drive", "hard-hat", "hash", "haze", "headphones", "heart", "help-circle", "hexagon", "highlighter", "history", "home", "image-minus", "image-off", "image-plus", "image", "import", "inbox", "indent", "indian-rupee", "infinity", "lucide-info", "inspect", "instagram", "italic", "japanese-yen", "key", "keyboard", "landmark", "lucide-languages", "laptop-2", "laptop", "lasso-select", "lasso", "layers", "layout-dashboard", "layout-grid", "layout-list", "layout-template", "layout", "library", "life-buoy", "lightbulb-off", "lightbulb", "link-2-off", "link-2", "lucide-link", "linkedin", "list-checks", "list-minus", "list-ordered", "list-plus", "list-x", "list", "loader-2", "loader", "locate-fixed", "locate-off", "locate", "lock", "log-in", "log-out", "mail", "map-pin", "map", "maximize-2", "maximize", "megaphone", "meh", "menu", "message-circle", "message-square", "mic-off", "mic", "minimize-2", "minimize", "minus-circle", "minus-square", "minus", "monitor-off", "monitor-speaker", "monitor", "moon", "more-horizontal", "more-vertical", "mountain-snow", "mountain", "mouse-pointer-2", "mouse-pointer-click", "mouse-pointer", "mouse", "move-diagonal-2", "move-diagonal", "move-horizontal", "move-vertical", "move", "music", "navigation-2", "navigation", "network", "octagon", "option", "outdent", "package-check", "package-minus", "package-plus", "package-search", "package-x", "package", "palette", "palmtree", "paperclip", "pause-circle", "pause-octagon", "pause", "pen-tool", "lucide-pencil", "percent", "person-standing", "phone-call", "phone-forwarded", "phone-incoming", "phone-missed", "phone-off", "phone-outgoing", "phone", "pie-chart", "piggy-bank", "lucide-pin", "pipette", "plane", "play-circle", "play", "plug-zap", "plus-circle", "plus-square", "plus", "pocket", "podcast", "pointer", "pound-sterling", "power-off", "power", "printer", "qr-code", "quote", "radio-receiver", "radio", "redo", "refresh-ccw", "refresh-cw", "regex", "repeat-1", "repeat", "reply-all", "reply", "rewind", "rocket", "rocking-chair", "rotate-ccw", "rotate-cw", "rss", "ruler", "russian-ruble", "save", "scale", "scan-line", "scan", "scissors", "screen-share-off", "screen-share", "lucide-search", "send", "separator-horizontal", "separator-vertical", "server-crash", "server-off", "server", "settings-2", "settings", "share-2", "share", "sheet", "shield-alert", "shield-check", "shield-close", "shield-off", "shield", "shirt", "shopping-bag", "shopping-cart", "shovel", "shrink", "shuffle", "sidebar-close", "sidebar-open", "sidebar", "sigma", "signal-high", "signal-low", "signal-medium", "signal-zero", "signal", "skip-back", "skip-forward", "skull", "slack", "slash", "sliders", "smartphone-charging", "smartphone", "smile", "snowflake", "sort-asc", "sort-desc", "speaker", "sprout", "square", "star-half", "lucide-star", "stop-circle", "stretch-horizontal", "stretch-vertical", "strikethrough", "subscript", "sun", "sunrise", "sunset", "superscript", "swiss-franc", "switch-camera", "table", "tablet", "tag", "target", "tent", "terminal-square", "terminal", "text-cursor-input", "text-cursor", "thermometer-snowflake", "thermometer-sun", "thermometer", "thumbs-down", "thumbs-up", "ticket", "timer-off", "timer-reset", "timer", "toggle-left", "toggle-right", "tornado", "trash-2", "lucide-trash", "trello", "trending-down", "trending-up", "triangle", "truck", "tv-2", "tv", "twitch", "twitter", "type", "umbrella", "underline", "undo", "unlink-2", "unlink", "unlock", "upload-cloud", "upload", "user-check", "user-minus", "user-plus", "user-x", "user", "users", "verified", "vibrate", "video-off", "video", "view", "voicemail", "volume-1", "volume-2", "volume-x", "volume", "wallet", "wand", "watch", "waves", "webcam", "wifi-off", "wifi", "wind", "wrap-text", "wrench", "x-circle", "x-octagon", "x-square", "x", "youtube", "zap-off", "zap", "zoom-in", "zoom-out", "search-large", "lucide-search"];
/**
 * The original ICON_LIST contains duplicate entries (e.g. two "activity" items) and is not in alphabetical order. This list improves it.
 */
const ICON_LIST_SORTED_UNIQUE = uniqueArray(ICON_LIST).sort();

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * TODO: Rename this class. Replace the T prefix with something else. The T stands for Type (kind of like TFile from Obsidian), but this is not a type, this is a class. Maybe ShellCommandInstance? It's not the best name, but I can't come up with a better one now.
 */
class TShellCommand {
    constructor(plugin, configuration) {
        this.plugin = plugin;
        this.configuration = configuration;
        // Introduce the ID to an ID generator so that it won't accidentally generate the same ID again when creating new shell commands.
        getIDGenerator().addReservedID(configuration.id);
    }
    getPlugin() {
        return this.plugin;
    }
    /**
     * Use this when you need to alter the configuration values. if you only need to read configuration values, use get*()
     * methods instead.
     */
    getConfiguration() {
        return this.configuration;
    }
    getId() {
        return this.configuration.id;
    }
    getShell() {
        // Check if the shell command has defined a specific shell.
        const shell = this.configuration.shells[getOperatingSystem()];
        if (undefined === shell) {
            // The shell command does not define an explicit shell.
            // Use a default shell from the plugin's settings.
            return this.plugin.getDefaultShell();
        }
        else {
            // The shell command has an explicit shell defined.
            return shell;
        }
    }
    getShells() {
        return this.configuration.shells;
    }
    /**
     * Returns a shell command string specific for the current operating system, or a generic shell command if this shell
     * command does not have an explicit version for the current OS.
     */
    getShellCommand() {
        // Check if the shell command has defined a specific command for this operating system.
        const platformSpecificShellCommand = this.configuration.platform_specific_commands[getOperatingSystem()];
        if (undefined === platformSpecificShellCommand) {
            // No command is defined specifically for this operating system.
            // Return an "OS agnostic" command.
            return this.configuration.platform_specific_commands.default;
        }
        else {
            // The shell command has defined a specific command for this operating system.
            return platformSpecificShellCommand;
        }
    }
    /**
     * Returns a version of the shell command that should be used if no platform specific command is defined for the
     * current platform. If you plan to use this for execution, consider using getShellCommand() instead, as it takes the
     * current platform into account.
     */
    getDefaultShellCommand() {
        return this.configuration.platform_specific_commands.default;
    }
    getPlatformSpecificShellCommands() {
        return this.configuration.platform_specific_commands;
    }
    /**
     * Returns a list of PlatformIds that have a shell command version defined. 'default' is never included in the list.
     *
     * TODO: Invent a better name for this method.
     */
    getNonEmptyPlatformIds() {
        const platform_specific_shell_commands = this.getPlatformSpecificShellCommands();
        const platform_ids_with_non_empty_shell_commands = [];
        let platform_id;
        for (platform_id in PlatformNames) { // Note that this loop does not iterate 'default' platform id (= the fallback platform id that is used when a shell command does not have a version for the current platform).
            const platform_specific_shell_command = platform_specific_shell_commands[platform_id];
            if (platform_specific_shell_command && "" !== platform_specific_shell_command.trim()) {
                platform_ids_with_non_empty_shell_commands.push(platform_id);
            }
        }
        return platform_ids_with_non_empty_shell_commands;
    }
    getIconId() {
        return this.configuration.icon;
    }
    getIconHTML() {
        if (this.configuration.icon) {
            // An icon is defined.
            return getIconHTML(this.configuration.icon);
        }
        else {
            // No icon is defined.
            return "";
        }
    }
    getAlias() {
        return this.configuration.alias;
    }
    /**
     * TODO: Use this method in all places where similar logic is needed.
     */
    getAliasOrShellCommand() {
        return this.configuration.alias || this.getShellCommand();
    }
    getConfirmExecution() {
        return this.configuration.confirm_execution;
    }
    getIgnoreErrorCodes() {
        return this.configuration.ignore_error_codes;
    }
    getInputChannels() {
        return this.configuration.input_contents;
    }
    getOutputChannelOrder() {
        return this.configuration.output_channel_order;
    }
    getOutputChannels() {
        return this.configuration.output_channels;
    }
    getOutputHandlingMode() {
        return this.configuration.output_handling_mode;
    }
    /**
     * Finds an output wrapper that should be used for the given OutputStream. Returns null, if no OutputWrapper should
     * be used.
     *
     * @param output_stream
     */
    getOutputWrapper(output_stream) {
        const output_wrapper_id = this.configuration.output_wrappers[output_stream];
        if (!output_wrapper_id) {
            // No output wrapper is defined for this output stream in this shell command.
            return null;
        }
        for (const output_wrapper of this.plugin.getOutputWrappers().values()) {
            // Check if this is the output wrapper defined for this shell command.
            if (output_wrapper.getID() === output_wrapper_id) {
                // The correct output wrapper was found.
                return output_wrapper;
            }
        }
        throw new Error("OutputWrapper with ID " + output_wrapper_id + " was not found.");
    }
    /**
     * Checks if different output streams can be wrapped together. In addition to this, combining output streams also
     * requires the OutputChannels to be the same, but that's not checked in this method.
     */
    isOutputWrapperStdoutSameAsStderr() {
        return this.configuration.output_wrappers["stdout"] === this.configuration.output_wrappers["stderr"];
    }
    getEventsConfiguration() {
        return this.configuration.events;
    }
    getEventConfiguration(sc_event) {
        return this.getEventsConfiguration()[sc_event.static().getCode()] || sc_event.getDefaultConfiguration(false);
    }
    isSC_EventEnabled(event_code) {
        const events_configuration = this.getEventsConfiguration();
        if (undefined === events_configuration[event_code]) {
            // Not enabled
            return false;
        }
        else {
            // Maybe enabled
            return events_configuration[event_code].enabled;
        }
    }
    /**
     * Called when changing event settings in ShellCommandExtraOptionsModal.
     * plugin.saveSettings() needs to be called after this!
     *
     * @param sc_event
     */
    enableSC_Event(sc_event) {
        const event_code = sc_event.static().getCode();
        const events_configuration = this.getEventsConfiguration();
        if (undefined === events_configuration[event_code]) {
            // Not enabled
            // Enable
            events_configuration[event_code] = sc_event.getDefaultConfiguration(true);
        }
        else {
            // Maybe enabled
            if (!events_configuration[event_code].enabled) {
                events_configuration[event_code].enabled = true;
            }
        }
        if (sc_event.canRegisterAfterChangingSettings()) {
            this.registerSC_Event(sc_event);
        }
        sc_event.onAfterEnabling(this);
    }
    /**
     * Called when changing event settings in ShellCommandExtraOptionsModal.
     * plugin.saveSettings() needs to be called after this!
     *
     * @param sc_event
     */
    disableSC_Event(sc_event) {
        const event_code = sc_event.static().getCode();
        const events_configuration = this.getEventsConfiguration();
        if (undefined !== events_configuration[event_code]) {
            // Maybe enabled
            if (events_configuration[event_code].enabled) {
                // Is enabled.
                // Disable.
                const configuration_property_names = Object.getOwnPropertyNames(events_configuration[event_code]);
                if (configuration_property_names.length > 1) {
                    // There's more settings than just 'enable'.
                    // Disable by setting 'enable' to false, don't flush the settings, they can be useful if the event gets re-enabled.
                    events_configuration[event_code].enabled = false;
                }
                else {
                    // 'enabled' is the only setting.
                    // Disable by removing the configuration object completely to make the settings file cleaner.
                    delete events_configuration[event_code];
                }
            }
        }
        if (sc_event.canRegisterAfterChangingSettings()) {
            this.unregisterSC_Event(sc_event);
        }
    }
    /**
     * Returns all SC_Events that are enabled fro this shell command.
     *
     * Private as it's currently only used domestically, but can be changed to public if needed.
     */
    getSC_Events() {
        const enabled_sc_events = [];
        getSC_Events(this.plugin).forEach((sc_event) => {
            if (this.isSC_EventEnabled(sc_event.static().getCode())) {
                enabled_sc_events.push(sc_event);
            }
        });
        return enabled_sc_events;
    }
    /**
     * Private, if you need access from outside, use enableSC_Event().
     *
     * @param sc_event
     * @private
     */
    registerSC_Event(sc_event) {
        sc_event.register(this);
    }
    /**
     * Private, if you need access from outside, use disableSC_Event().
     *
     * @param sc_event
     * @private
     */
    unregisterSC_Event(sc_event) {
        sc_event.unregister(this);
    }
    /**
     * Set's up all events that are enabled for this shell command.
     *
     * @param called_after_changing_settings Set to: true, if this happens after changing configuration; false, if this happens during loading the plugin.
     */
    registerSC_Events(called_after_changing_settings) {
        this.getSC_Events().forEach((sc_event) => {
            const can_register = !called_after_changing_settings || sc_event.canRegisterAfterChangingSettings();
            if (can_register) {
                this.registerSC_Event(sc_event);
            }
        });
    }
    unregisterSC_Events() {
        this.getSC_Events().forEach((sc_event) => {
            this.unregisterSC_Event(sc_event);
        });
    }
    registerToCommandPalette() {
        // TODO: Move the logic from plugin.registerShellCommand() to here, but split to multiple methods.
        this.plugin.registerShellCommand(this);
    }
    unregisterFromCommandPalette() {
        // FIXME: I think the unregistering does not work.
        delete this.plugin.obsidian_commands[this.getId()];
    }
    /**
     * Checks the configuration for command_palette_availability and returns:
     *  - true, if the value is "enabled" or "unlisted"
     *  - false, if the value is "disabled"
     *
     * Adding to command palette also enables hotkeys, which is why adding can be permitted, but showing denied, if a shell command should only be available via hotkeys.
     */
    canAddToCommandPalette() {
        return this.getConfiguration().command_palette_availability !== "disabled";
    }
    /**
     * Another name for canAddToCommandPalette().
     */
    canHaveHotkeys() {
        return this.canAddToCommandPalette();
    }
    /**
     * Checks the configuration for command_palette_availability and returns:
     *  - true, if the value is "enabled"
     *  - false, if the value is "disabled" or "unlisted"
     */
    canShowInCommandPalette() {
        return this.getConfiguration().command_palette_availability === "enabled";
    }
    /**
     * Creates a new ParsingProcess instance and defines two sets of variables:
     *  - First set: All variables that are not tied to any preactions.
     *  - Second set: Variables that are tied to preactions. Can be an empty set.
     * You need to still call ParsingProcess.process() to parse the first set. ShellCommandExecutor takes care of calling
     * ParsingProcess.processRest() to process all non-processed sets.
     *
     * @See ParsingProcess class for a description of the process.
     * @param sc_event Needed to get {{event_*}} variables parsed. Can be left out if working outside any SC_Event context, in which case {{event_*}} variables are inaccessible.
     */
    createParsingProcess(sc_event) {
        const stdout_output_wrapper = this.getOutputWrapper("stdout"); // Can be null
        const stderr_output_wrapper = this.getOutputWrapper("stderr"); // Can be null
        return new ParsingProcess(this.plugin, {
            shell_command: this.getShellCommand(),
            alias: this.getAlias(),
            environment_variable_path_augmentation: getPATHAugmentation(this.plugin) ?? "",
            stdinContent: this.configuration.input_contents.stdin ?? undefined,
            output_wrapper_stdout: stdout_output_wrapper ? stdout_output_wrapper.getContent() : undefined,
            output_wrapper_stderr: stderr_output_wrapper ? stderr_output_wrapper.getContent() : undefined,
        }, this, sc_event, [
            this.getNonPreactionsDependentVariables(),
            this.getPreactionsDependentVariables(), // Second set: Variables that are tied to preactions. Can be an empty set.
        ], [
            // Do not escape variables in stdin, because shells won't interpret special characters in stdin. All characters are considered literal.
            "stdinContent",
            // Do not escape variables in output wrappers, because they are not going through a shell and escape characters would be visible in the end result.
            'output_wrapper_stdout',
            'output_wrapper_stderr',
        ]);
    }
    setObsidianCommand(obsidian_command) {
        this.obsidian_command = obsidian_command;
    }
    getObsidianCommand() {
        return this.obsidian_command;
    }
    /**
     * No renaming is done if the shell command is excluded from the command palette.
     */
    renameObsidianCommand(shell_command, alias) {
        // Rename the command in command palette
        const prefix = this.plugin.getPluginName() + ": "; // Normally Obsidian prefixes all commands with the plugin name automatically, but now that we are actually _editing_ a command in the palette (not creating a new one), Obsidian won't do the prefixing for us.
        // Check that the shell command is actually registered to Obsidian's command palette.
        if (undefined !== this.obsidian_command) {
            // Yes, the shell command is registered in Obsidian's command palette.
            // Update the command palette name.
            this.obsidian_command.name = prefix + generateObsidianCommandName(this.plugin, shell_command, alias);
        }
        // If the shell command's "command_palette_availability" settings is set to "disabled", then the shell command is not present in this.obsidian_command and so the command palette name does not need updating.
    }
    /**
     * Clears an internal cache used by .getPreactions().
     * Only needed to be called after creating new PreactionConfigurations or deleting old ones. Should not need to be called
     * when modifying properties in existing PreactionConfigurations.
     */
    resetPreactions() {
        debugLog(`TShellCommand ${this.getId()}: Resetting preactions.`);
        delete this.cached_preactions;
    }
    getPreactions() {
        debugLog(`TShellCommand ${this.getId()}: Getting preactions.`);
        if (!this.cached_preactions) {
            this.cached_preactions = [];
            let preaction_configuration;
            for (preaction_configuration of this.getConfiguration().preactions) {
                // Only create the preaction if it's enabled.
                if (preaction_configuration.enabled) {
                    // Yes, it's enabled.
                    // Instantiate the Preaction.
                    this.cached_preactions.push(createPreaction(this.plugin, preaction_configuration, this));
                }
            }
        }
        return this.cached_preactions;
    }
    /**
     * Returns Variables that are not dependent on any Preaction.
     * @private Can be made public if needed.
     */
    getNonPreactionsDependentVariables() {
        debugLog(`TShellCommand ${this.getId()}: Getting non preactions dependent variables.`);
        const all_variables = this.plugin.getVariables();
        return removeFromSet(all_variables, this.getPreactionsDependentVariables());
    }
    /**
     * @private Can be made public if needed.
     */
    getPreactionsDependentVariables() {
        debugLog(`TShellCommand ${this.getId()}: Getting preactions dependent variables.`);
        let dependent_variables = new VariableSet();
        for (const preaction of this.getPreactions()) {
            dependent_variables = mergeSets(dependent_variables, preaction.getDependentVariables());
        }
        return dependent_variables;
    }
    /**
     * @return Returns undefined, if no configuration is defined for this variable.
     * @param variable
     * @param canInherit If true, can get default value configuration from Variable configuration (= upper level configuration in this case). Can be set to false in situations where it's important to know what the shell command itself has defined or not defined.
     */
    getDefaultValueConfigurationForVariable(variable, canInherit = true) {
        const defaultValueConfiguration = this.configuration.variable_default_values[variable.getIdentifier()];
        if (undefined === defaultValueConfiguration || defaultValueConfiguration.type === "inherit") {
            // This shell command does not specify a default value.
            if (canInherit) {
                // Return a global configuration (but even that can be undefined).
                return variable.getGlobalDefaultValueConfiguration(); // Can return undefined.
            }
            // If inheriting is denied, pass to return the defaultValueConfiguration that were gotten from this.configuration.variable_default_values.
        }
        return defaultValueConfiguration;
    }
    /**
     * Returns an URI that can be used in links (in or outside of Obsidian) to execute this shell command. The URI also
     * contains stubs for any possible CustomVariables that might be used in the shell command (if any).
     */
    getExecutionURI() {
        const execution_uri = this.plugin.getObsidianURI(SC_Plugin.SHELL_COMMANDS_URI_ACTION, { execute: this.getId() });
        // Get a list CustomVariables that the shell command uses.
        const custom_variables = new VariableSet();
        for (const custom_variable of getUsedVariables(this.plugin, this.getShellCommand())) {
            // Check that the variable IS a CustomVariable.
            if (custom_variable instanceof CustomVariable) {
                custom_variables.add(custom_variable);
            }
        }
        // Exclude variables whose values will come from Preactions - they will not probably be needed in the URI.
        const custom_variables_suitable_for_uri = removeFromSet(custom_variables, this.getPreactionsDependentVariables());
        // Append the suitable custom variable names to the uri.
        let execution_uri_with_variables = execution_uri;
        for (const custom_variable of custom_variables_suitable_for_uri) {
            execution_uri_with_variables += "&" + custom_variable.variable_name + "=";
        }
        // Finished.
        return execution_uri_with_variables;
    }
    /**
     * Returns an adjacent TShellCommand that appears next in the configuration list. Returns undefined, if this is the
     * last TShellCommand. Used in settings to switch quickly from one TShellCommand to another.
     */
    nextTShellCommand() {
        const t_shell_commands = Object.values(this.plugin.getTShellCommands());
        const this_index = t_shell_commands.indexOf(this);
        if (this_index === t_shell_commands.length - 1) {
            return undefined;
        }
        return t_shell_commands[this_index + 1];
    }
    /**
     * Returns an adjacent TShellCommand that appears before in the configuration list. Returns undefined, if this is the
     * first TShellCommand. Used in settings to switch quickly from one TShellCommand to another.
     */
    previousTShellCommand() {
        const t_shell_commands = Object.values(this.plugin.getTShellCommands());
        const this_index = t_shell_commands.indexOf(this);
        if (this_index === 0) {
            return undefined;
        }
        return t_shell_commands[this_index - 1];
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function createVariableDefaultValueFields(plugin, containerElement, targetObject) {
    // Add default value fields for each variable that can have a default value.
    for (const variable of plugin.getVariables()) {
        // Only add fields for variables that are not always accessible.
        if (!variable.isAlwaysAvailable()) {
            const setting = createVariableDefaultValueField(plugin, containerElement, variable.getFullName(), variable, targetObject);
            // Documentation link
            if (!(variable instanceof CustomVariable)) {
                setting.addExtraButton(extraButton => extraButton
                    .setIcon("help")
                    .setTooltip("Documentation: " + variable.getFullName() + " variable")
                    .onClick(() => gotoURL(variable.getDocumentationLink())));
            }
        }
    }
}
/**
 *
 * @param plugin
 * @param containerElement
 * @param settingName
 * @param variable The variable whose default value will be configured by the created setting field.
 * @param targetObject In which object's configuration the default value settings should be stored. Can be a TShellCommand or a Variable (either CustomVariable or a built-in one).
 */
function createVariableDefaultValueField(plugin, containerElement, settingName, variable, targetObject) {
    if (undefined === targetObject) {
        // No configuration target is defined, so use the variable as a target.
        targetObject = variable;
    }
    const targetType = targetObject instanceof TShellCommand
        ? 'tShellCommand'
        : targetObject instanceof CustomVariable
            ? 'customVariable'
            : 'builtinVariable';
    if ("customVariable" === targetType || "builtinVariable" === targetType) {
        if (targetObject !== variable) {
            throw new Error("If defining 'targetObject' argument as a Variable, it should be the same as the 'variable' argument.");
        }
    }
    // Get an identifier for a variable (an id, if it's a CustomVariable, otherwise the variable's name).
    const variableIdentifier = variable.getIdentifier();
    // If a default value has been defined for this variable (and this targetObject), retrieve the configuration.
    let defaultValueConfiguration;
    switch (targetType) {
        case "tShellCommand":
            defaultValueConfiguration = targetObject.getDefaultValueConfigurationForVariable(variable, false);
            break;
        case "builtinVariable": // Both classes have...
        case "customVariable": // ... the getGlobalDefaultValueConfiguration() method.
            defaultValueConfiguration = targetObject.getGlobalDefaultValueConfiguration();
            break;
    }
    // A function for creating configuration in onChange() callbacks if the variable does not yet have one for this configuration.
    const createDefaultValueConfiguration = () => {
        const configuration = {
            type: "show-errors",
            value: "",
        };
        // Store the configuration to the target object's configuration.
        switch (targetType) {
            case "tShellCommand":
                targetObject.getConfiguration().variable_default_values[variableIdentifier] = configuration;
                break;
            case "builtinVariable":
                if (undefined === plugin.settings.builtin_variables[variableIdentifier]) {
                    // Create a config object for this variable if it does not exist yet.
                    plugin.settings.builtin_variables[variableIdentifier] = { default_value: null };
                }
                plugin.settings.builtin_variables[variableIdentifier].default_value = configuration;
                break;
            case "customVariable":
                targetObject.getConfiguration().default_value = configuration;
                break;
        }
        return configuration;
    };
    let textareaComponent;
    // A function for updating textareaComponent visibility.
    const updateTextareaComponentVisibility = (type) => {
        if ("value" === type) {
            textareaComponent.inputEl.removeClass("SC-hide");
        }
        else {
            textareaComponent.inputEl.addClass("SC-hide");
        }
    };
    // Define a set of options for default value type
    const defaultValueTypeOptions = {
        "inherit": "",
        "show-errors": "Cancel execution and show errors",
        "cancel-silently": "Cancel execution silently",
        "value": "Execute with value:",
    };
    switch (targetType) {
        case "tShellCommand": {
            // Shell commands can have the "inherit" type.
            const globalDefaultValueConfiguration = variable.getGlobalDefaultValueConfiguration();
            const globalDefaultValueType = globalDefaultValueConfiguration ? globalDefaultValueConfiguration.type : "show-errors";
            defaultValueTypeOptions.inherit = "Inherit: " + defaultValueTypeOptions[globalDefaultValueType];
            if ("value" === globalDefaultValueType) {
                defaultValueTypeOptions.inherit += " " + globalDefaultValueConfiguration?.value;
            }
            break;
        }
        case "builtinVariable":
        case "customVariable": {
            // Variables do not have the "inherit" type.
            // @ts-ignore Don't yell about removing a non-optional property "inherit".
            delete defaultValueTypeOptions.inherit;
        }
    }
    // Create the default value setting
    const defaultValueSetting = new obsidian.Setting(containerElement)
        .setName(settingName)
        .setDesc("If not available, then:")
        .setTooltip(variable.getAvailabilityTextPlain())
        .addDropdown(dropdown => dropdown
        .addOptions(defaultValueTypeOptions)
        .setValue(defaultValueConfiguration
        ? defaultValueConfiguration.type
        : "tShellCommand" === targetType
            ? "inherit" // If configuring a TShellCommand, then default config type should be "inherit".
            : "show-errors" // If configuring a Variable, then default config type should be "show-errors", because "inherit" is not available.
    )
        .onChange(async (newType) => {
        if (!defaultValueConfiguration) {
            defaultValueConfiguration = createDefaultValueConfiguration();
        }
        // Set the new type
        defaultValueConfiguration.type = newType;
        if (targetType === "tShellCommand") {
            // Shell commands:
            if ("inherit" === newType && defaultValueConfiguration.value === "") {
                // If "inherit" is selected and no text value is typed, the configuration file can be cleaned up by removing this configuration object completely.
                // Prevent deleting, if a text value is present, because the user might want to keep it if they will later change 'type' to 'value'.
                delete targetObject.getConfiguration().variable_default_values[variableIdentifier];
            }
        }
        else {
            // Variables:
            if ("show-errors" === newType && defaultValueConfiguration.value === "") {
                // If "show-errors" is selected and no text value is typed, the configuration file can be cleaned up by removing this configuration object completely.
                // Prevent deleting, if a text value is present, because the user might want to keep it if they will later change 'type' to 'value'.
                switch (targetType) {
                    case "builtinVariable":
                        plugin.settings.builtin_variables[variableIdentifier].default_value = null;
                        break;
                    case "customVariable":
                        targetObject.getConfiguration().default_value = null;
                        break;
                }
            }
        }
        // Show/hide the textarea
        updateTextareaComponentVisibility(newType);
        // Save the settings
        await plugin.saveSettings();
    }))
        .addTextArea(textarea => textareaComponent = textarea
        .setValue(defaultValueConfiguration ? defaultValueConfiguration.value : "")
        .onChange(async (newValue) => {
        if (!defaultValueConfiguration) {
            defaultValueConfiguration = createDefaultValueConfiguration();
        }
        // Set the new text value
        defaultValueConfiguration.value = newValue;
        // Save the settings
        await plugin.saveSettings();
    }).then((textareaComponent) => {
        // Autocomplete for the textarea.
        if (plugin.settings.show_autocomplete_menu) {
            createAutocomplete(plugin, textareaComponent.inputEl, () => textareaComponent.onChanged());
        }
    }));
    updateTextareaComponentVisibility(defaultValueConfiguration
        ? defaultValueConfiguration.type
        : targetType === "tShellCommand"
            ? "show-errors" // It does not really matter if passing "show-errors" ....
            : "inherit");
    return defaultValueSetting;
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class CustomVariableModel extends Model {
    constructor() {
        super(...arguments);
        this.custom_variable_instances = new CustomVariableInstanceMap;
    }
    getSingularName() {
        return "Custom variable";
    }
    defineParentConfigurationRelation(custom_variable_instance) {
        debugLog(`CustomVariableModel: Defining parent configuration relation for CustomVariableInstance ${custom_variable_instance.getID()}.`);
        return {
            type: "one-to-many-id",
            key: "custom_variables",
            id: custom_variable_instance.getID(),
        };
    }
    loadInstances(parent_configuration) {
        debugLog(`CustomVariableModel: Loading CustomVariableInstances.`);
        this.custom_variable_instances.clear();
        parent_configuration.custom_variables.forEach((custom_variable_configuration) => {
            this.custom_variable_instances.set(custom_variable_configuration.id, new CustomVariableInstance(this, custom_variable_configuration, parent_configuration));
        });
        return this.custom_variable_instances;
    }
    newInstance(parent_configuration) {
        debugLog(`CustomVariableModel: Creating a new CustomVariableInstance.`);
        // Create a default configuration object
        const custom_variable_configuration = this.getDefaultConfiguration();
        parent_configuration.custom_variables.push(custom_variable_configuration);
        // Create a CustomVariableInstance for handling the configuration
        const custom_variable_instance = new CustomVariableInstance(this, custom_variable_configuration, parent_configuration);
        this.custom_variable_instances.set(custom_variable_configuration.id, custom_variable_instance);
        // Create an operational variable.
        this.plugin.getVariables().add(custom_variable_instance.createCustomVariable());
        return custom_variable_instance;
        // TODO: Move this logic to the base Model class.
    }
    _createSettingFields(instance, container_element) {
        debugLog(`CustomVariableModel: Creating setting fields for CustomVariableInstance ${instance.getID()}.`);
        // Make the fields appear closer together.
        container_element.addClass("SC-setting-group");
        // Heading setting
        const heading_setting = new obsidian.Setting(container_element)
            .setName(instance.getFullName())
            .setHeading();
        // Name setting
        new obsidian.Setting(container_element)
            .setName("Variable name")
            .setDesc("Must contain at least one character. Allowed characters are letters a-z, numbers 0-9 and an underscore _")
            .setClass("SC-custom-variable-name-setting")
            .addText(text => text
            .setValue(instance.configuration.name)
            .onChange((new_name) => {
            // TODO: Find a way to create this kind of trivial onChange() functions in the Model base class.
            instance.setIfValid("name", new_name).then(async () => {
                // Valid
                heading_setting.setName(instance.getFullName()); // Also removes a possible warning message.
                instance.getCustomVariable().updateProperties(); // Update the name also to the operational variable, not only in configuration.
                await this.plugin.saveSettings();
                await this.plugin.updateCustomVariableViews();
            }, (reason) => {
                // Not valid
                if (typeof reason === "string") {
                    // This is a validation error message.
                    // Display a warning message.
                    heading_setting.setName(reason + " The name was not saved.");
                }
                else {
                    // Some other runtime error has occurred.
                    throw reason;
                }
            });
        }));
        // Description setting
        new obsidian.Setting(container_element)
            .setName("Description")
            .setDesc("Appears in autocomplete lists along with the variable name, and also in the 'Custom variables' pane, if you use it.")
            .addText(text => text
            .setValue(instance.configuration.description)
            .onChange(async (new_description) => {
            // TODO: Find a way to create this kind of trivial onChange() functions in the Model base class.
            instance.configuration.description = new_description;
            instance.getCustomVariable().updateProperties(); // Update the description also to the operational variable, not only in configuration.
            await this.plugin.saveSettings();
            await this.plugin.updateCustomVariableViews();
        }));
        // Default value setting
        createVariableDefaultValueField(this.plugin, container_element, "Default value", instance.getCustomVariable());
        return heading_setting;
    }
    validateValue(custom_variable_instance, field, custom_variable_name) {
        debugLog(`CustomVariableModel: Validating ${field} value ${custom_variable_name} for CustomVariableInstance ${custom_variable_instance.getID()}.`);
        return new Promise((resolve, reject) => {
            switch (field) {
                case "name":
                    // Check that the name contains only characters a-z, 0-9 and/or underline _
                    if (!custom_variable_name.match(/^[\w\d]+$/u)) {
                        // Incorrect format.
                        reject(`The name {{_${custom_variable_name}}} does not meet the naming requirements.`);
                        return;
                    }
                    // Check if the name is a duplicate.
                    if (this.isCustomVariableNameDuplicate(custom_variable_name, custom_variable_instance)) {
                        // It's a duplicate.
                        reject(`The name {{_${custom_variable_name}}} is already reserved.`);
                    }
                    else {
                        // It's unique.
                        resolve();
                    }
                    return;
                default:
                    // Other fields do not need validation.
                    resolve();
                    return;
            }
        });
    }
    getDefaultConfiguration() {
        // Generate a unique name for the variable by using a sequential number.
        let sequential_number = 1;
        while (this.isCustomVariableNameDuplicate(String(sequential_number))) {
            sequential_number++;
        }
        // Create a configuration object.
        return {
            id: getIDGenerator().generateID(),
            name: String(sequential_number),
            description: "",
            default_value: null,
        };
    }
    async _deleteInstance(custom_variable_instance) {
        debugLog(`CustomVariableModel: Deleting CustomVariableInstance ${custom_variable_instance.getID()}.`);
        // Remove the CustomVariableInstance from all PromptFields that use it.
        for (const prompt of this.plugin.getPrompts().values()) {
            for (const prompt_field of prompt.prompt_fields) {
                if (custom_variable_instance.getID() === prompt_field.configuration.target_variable_id) {
                    // This prompt field uses this CustomVariableInstance.
                    // Remove the variable from use.
                    prompt_field.configuration.target_variable_id = "";
                    // Saving is done later, after the _deleteInstance() call.
                }
            }
        }
        // Delete CustomVariable
        try {
            this.plugin.getVariables().delete(custom_variable_instance.getCustomVariable());
        }
        catch (error) {
            // If custom_variable_instance.getCustomVariable() failed, no need to do anything. It just means there is no CustomVariable, so there's nothing to delete.
        }
        // Delete CustomVariableInstance
        this.custom_variable_instances.delete(custom_variable_instance.getID());
        // remove the variable from custom variable side panes.
        await this.plugin.updateCustomVariableViews();
    }
    /**
     * Can be changed to public if needed.
     */
    isCustomVariableNameDuplicate(custom_variable_name, ignore_custom_variable_instance) {
        let is_duplicate = false;
        this.custom_variable_instances.forEach((custom_variable2_instance, custom_variable_id) => {
            // First check can the current custom variable attend to the duplicate test.
            if (ignore_custom_variable_instance && custom_variable_id === ignore_custom_variable_instance.getID()) {
                // Don't check this instance. This skipping is used for the current owner of the name.
                return;
            }
            // Now do the actual duplicate test.
            if (custom_variable_name.toLocaleLowerCase() === custom_variable2_instance.configuration.name.toLocaleLowerCase()) {
                is_duplicate = true;
            }
        });
        return is_duplicate;
    }
}
class CustomVariableInstanceMap extends Map {
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class CustomVariableSettingsModal extends SC_Modal {
    constructor(plugin, custom_variable_instance, on_after_creation, on_after_cancelling) {
        super(plugin);
        this.custom_variable_instance = custom_variable_instance;
        this.on_after_creation = on_after_creation;
        this.on_after_cancelling = on_after_cancelling;
        this.created = false;
    }
    onOpen() {
        super.onOpen();
        const model = getModel(CustomVariableModel.name);
        model.createSettingFields(this.custom_variable_instance, this.modalEl, false);
        new obsidian.Setting(this.modalEl)
            .addButton(button => button
            .setButtonText("Create")
            .onClick(() => this.approve()));
    }
    approve() {
        this.created = true;
        this.on_after_creation();
        this.close();
    }
    onClose() {
        super.onClose();
        if (!this.created) {
            this.on_after_cancelling();
        }
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class CustomVariableView extends obsidian.ItemView {
    constructor(plugin, leaf) {
        super(leaf);
        this.plugin = plugin;
    }
    getDisplayText() {
        return "Custom variables";
    }
    getViewType() {
        return CustomVariableView.ViewType;
    }
    getIcon() {
        return "code-glyph";
    }
    async onOpen() {
        this.container_element = this.containerEl.children[1].createDiv(); // I don't know why I cannot create elements directly under this.containerEl (they wouldn't show up). I did the same thing as was done here: https://marcus.se.net/obsidian-plugin-docs/guides/custom-views (referenced 2022-03-23).
        this.container_element.addClass("container");
        await this.updateContent();
    }
    async updateContent() {
        this.container_element.empty();
        this.container_element.createEl("h3", { text: "Custom variables" });
        const variableListElement = this.container_element.createEl("ul");
        for (const customVariableInstance of this.plugin.getCustomVariableInstances().values()) {
            let customVariableValue = (await customVariableInstance.getCustomVariable().getValue()).value;
            let customVariableState = null;
            if (null === customVariableValue) {
                // The variable has no value yet.
                if ("value" === customVariableInstance.configuration.default_value?.type) {
                    // Indicate that the variable has a default value defined, which will practically be used as long as no overriding value is set.
                    if ("" === customVariableInstance.configuration.default_value.value.trim()) {
                        customVariableState = "No value yet, but defaults to: An empty text.";
                    }
                    else {
                        customVariableState = "No value yet, but defaults to: "; // The value will appear next to the state text later below.
                        customVariableValue = customVariableInstance.configuration.default_value.value;
                    }
                }
                else {
                    // No default value is defined, so no value is accessible.
                    customVariableState = "No value yet.";
                }
            }
            else if ("" === customVariableValue) {
                customVariableState = "An empty text.";
            }
            const variableListItemElement = variableListElement.createEl("li", {
                text: customVariableInstance.getFullName(),
                attr: {
                    "aria-label": customVariableInstance.configuration.description,
                    "class": "SC-custom-variable-view-list-item",
                },
            });
            variableListItemElement.createEl("br");
            if (null !== customVariableState) {
                variableListItemElement.createEl("em").insertAdjacentText("beforeend", customVariableState);
            }
            if (null !== customVariableValue) {
                // Bold normal values to make them more prominent in contrast to variable names and "No value yet."/"An empty text." texts.
                variableListItemElement.createEl("strong").insertAdjacentText("beforeend", customVariableValue);
            }
        }
    }
}
CustomVariableView.ViewType = "SC-custom-variables-view";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Preaction {
    constructor(plugin, configuration, t_shell_command) {
        this.plugin = plugin;
        this.configuration = configuration;
        this.t_shell_command = t_shell_command;
    }
    /**
     * Maybe this wrapper method is unneeded, but have it for a while at least.
     */
    perform(parsing_process, sc_event) {
        return this.doPreaction(parsing_process, sc_event);
    }
    /**
     * Returns variables that are dependent of this Preaction, i.e. variables whose value is set by this Preaction.
     * If a variable is READ by a Preaction, it is NOT considered to be _dependent_ of the Preaction, as long as the variable's
     * value is not changed by the Preaction.
     *
     * By default, it returns an empty VariableSet, because not all Preactions will use variables at all.
     */
    getDependentVariables() {
        return new VariableSet();
    }
}
function createPreaction(plugin, preaction_configuration, t_shell_command) {
    switch (preaction_configuration.type) {
        case "prompt":
            return new Preaction_Prompt(plugin, preaction_configuration, t_shell_command);
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Preaction_Prompt extends Preaction {
    constructor(plugin, configuration, t_shell_command) {
        super(plugin, configuration, t_shell_command);
        this.configuration = configuration;
    }
    doPreaction(parsing_process, sc_event) {
        // TODO: Now that doPreaction() returns a similar Promise as is received from openPrompt(), consider just returning the same Promise instead of creating a new one.
        return new Promise((resolve) => {
            this.getPrompt().openPrompt(this.t_shell_command, parsing_process, sc_event).then((execution_confirmed) => {
                // The PromptModal has been closed.
                // Check if user wanted to execute the shell command or cancel.
                if (execution_confirmed) {
                    // User wants to execute.
                    resolve(true);
                }
                else {
                    // User wants to cancel.
                    resolve(false);
                }
            });
        });
    }
    /**
     * Returns all the CustomVariables whose values this Preaction's Prompt sets.
     */
    getDependentVariables() {
        const variables = new VariableSet();
        for (const prompt_field of this.getPrompt().prompt_fields) {
            // Check that the PromptField has a target variable defined. Otherwise getTargetVariable() would cause a crash.
            if ("" !== prompt_field.configuration.target_variable_id) {
                variables.add(prompt_field.getTargetVariable());
            }
        }
        return variables;
    }
    /**
     * TODO: Remove.
     */
    getDefaultConfiguration() {
        return {
            type: "prompt",
            enabled: false,
            prompt_id: "",
        };
    }
    getPrompt() {
        const promptId = this.configuration.prompt_id;
        if (undefined === promptId) {
            throw new Error("Prompt id is undefined in configuration.");
        }
        const prompt = this.plugin.getPrompts().get(promptId);
        if (undefined === prompt) {
            throw new Error("Prompt with id '" + promptId + "' does not exist");
        }
        return prompt;
    }
}
function getDefaultPreaction_Prompt_Configuration() {
    return {
        type: "prompt",
        enabled: false,
        prompt_id: "",
    };
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class PromptField extends Instance {
    constructor(model, prompt, configuration, prompt_field_index) {
        super(model, configuration, prompt.configuration);
        this.model = model;
        this.prompt = prompt;
        this.configuration = configuration;
        this.prompt_field_index = prompt_field_index;
        this.parsing_errors = [];
    }
    /**
     *
     * @param container_element
     * @param t_shell_command
     * @param sc_event Used when parsing variables for default_value and the inputted value. Needed so that also {{event_*}} variables can be used in prompts.
     */
    async createField(container_element, t_shell_command, sc_event) {
        await this._createField(container_element, t_shell_command, sc_event);
        // Create a preview setting element. It will not contain any actual setting elements, just text.
        this.preview_setting = new obsidian.Setting(container_element);
        // Parse variables in the default value and insert it to the field.
        // Note that this is a different "default value" than what TShellCommand considers as variables' default values! This is about a _field's_ default value, not a variable's default value. t_shell_command is passed in order to allow any possible variables in the field's default value to access the variables' default values (which come from TShellCommand).
        await this.applyDefaultValue(t_shell_command, sc_event);
    }
    getTitle() {
        return this.configuration.label === "" ? "Unlabelled field" : this.configuration.label;
    }
    /**
     * Parses the default value and sets it to the form element.
     * @param t_shell_command
     * @param sc_event
     * @private
     */
    async applyDefaultValue(t_shell_command, sc_event) {
        const default_value = this.configuration.default_value;
        const parsing_result = await parseVariables(this.prompt.model.plugin, default_value, null, t_shell_command, sc_event);
        if (!parsing_result.succeeded) {
            // Parsing failed.
            this.setValue(default_value); // Use the unparsed value. If default value contains a variable that cannot be parsed, a user can see the variable in the prompt modal and either fix it or change it to something else.
        }
        else {
            // Parsing succeeded.
            this.setValue(parsing_result.parsed_content);
        }
        await this.valueHasChanged(t_shell_command, sc_event);
    }
    getParsedValue() {
        return this.parsed_value;
    }
    /**
     * Tries to get a parsed value, but if it's not available (probably due to incorrect usage of variables), returns an
     * unparsed value instead().
     */
    getParsedOrRawValue() {
        return this.parsed_value ?? this.getValue();
    }
    getParsingErrors() {
        return this.parsing_errors;
    }
    /**
     * Updates this.parsed_value, this.parsing_errors and this.preview_setting .
     *
     * @param t_shell_command
     * @param sc_event
     * @protected
     */
    async valueHasChanged(t_shell_command, sc_event) {
        let preview;
        // Parse variables in the value.
        const parsing_result = await parseVariables(this.prompt.model.plugin, this.getValue(), null, t_shell_command, sc_event);
        if (!parsing_result.succeeded) {
            // Parsing failed.
            this.parsed_value = null;
            if (parsing_result.error_messages.length > 0) {
                // Display the first error message. If there are more, others can be omitted.
                preview = parsing_result.error_messages[0];
            }
            else {
                // If there are no error messages, then errors are silently ignored by user's variable configuration, in which case just show the original content.
                preview = parsing_result.original_content;
            }
            this.parsing_errors = parsing_result.error_messages;
        }
        else {
            // Parsing succeeded
            this.parsed_value = parsing_result.parsed_content;
            preview = parsing_result.parsed_content;
            this.parsing_errors = []; // No errors.
        }
        // Update the preview element.
        if (0 === parsing_result.count_parsed_variables) {
            // If no variables were used, hide the description as it's not needed to repeat the value that already shows up in the form field.
            preview = "";
        }
        this.preview_setting.setDesc(preview);
        // Call a possible external callback
        if (this.on_change_callback) {
            this.on_change_callback();
        }
    }
    /**
     * @param on_change_callback A callback that will be called whenever the field's value is changed.
     */
    onChange(on_change_callback) {
        this.on_change_callback = on_change_callback;
    }
    /**
     * @param on_focus_callback A callback that will be called whenever the field is focused.
     */
    onFocus(on_focus_callback) {
        this.on_focus_callback = on_focus_callback;
    }
    /**
     * Should be called by the subclass when the field has gotten focus.
     */
    hasGottenFocus() {
        if (this.on_focus_callback) {
            this.on_focus_callback(this);
        }
    }
    /**
     * Ensures that the field is filled, if it's mandatory. If the field is not mandatory, it's always valid.
     *
     * @return True when valid, false when not valid.
     */
    validate() {
        if (!this.configuration.required) {
            // No need to validate, because the field is not mandatory.
            return true;
        }
        // Ensure the field is filled
        return this.isFilled();
    }
    getTargetVariableInstance() {
        const target_variable_id = this.configuration.target_variable_id;
        const custom_variable_instance = this.prompt.model.plugin.getCustomVariableInstances().get(target_variable_id);
        if (!custom_variable_instance) {
            throw new Error(this.constructor.name + ".getTargetVariableInstance(): CustomVariableInstance with ID '" + target_variable_id + "' was not found");
        }
        return custom_variable_instance;
    }
    getTargetVariable() {
        const custom_variable_instance = this.getTargetVariableInstance();
        return custom_variable_instance.getCustomVariable();
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class PromptFieldModel extends Model {
    getSingularName() {
        return "Field";
    }
    defineParentConfigurationRelation(prompt_field) {
        return {
            type: "one-to-many-index",
            key: "fields",
            index: prompt_field.prompt_field_index,
        };
    }
    loadInstances(prompt) {
        const prompt_fields = new PromptFieldSet;
        prompt.configuration.fields.forEach((field_configuration, index) => {
            prompt_fields.add(this.createInstance(prompt, field_configuration, index));
        });
        return prompt_fields;
    }
    newInstance(prompt) {
        // TODO: Move this logic to the base Model class.
        // Setup a default configuration
        const prompt_field_configuration = this.getDefaultConfiguration();
        // Instantiate a PromptField
        const prompt_field = this.createInstance(prompt, prompt_field_configuration, prompt.configuration.fields.length);
        // Store the configuration into the prompt's configuration
        prompt.configuration.fields.push(prompt_field_configuration);
        // Store the PromptField instance into its parent Prompt's list of fields.
        prompt.prompt_fields.add(prompt_field);
        // Return the PromptField
        return prompt_field;
    }
    createInstance(prompt, prompt_field_configuration, prompt_field_index) {
        // TODO: When the 'type' field gets implemented on PromptFieldConfiguration, implement some kind of switch structure here to create different types of PromptFields.
        return new PromptField_Text(this, prompt, prompt_field_configuration, prompt_field_index);
    }
    _createSettingFields(prompt_field, container_element) {
        const label_placeholders = [
            "What is your name?",
            "How big is the universe?",
            "How long is eternity?",
            "What is your lucky number?",
            "What is your favorite song?",
            "What is your favorite color?",
            "How many books have you read?",
            "What is the purpose of life?",
        ];
        const default_value_placeholders = [
            ["Bond, James Bond", "John Doe", "Jane Doe", "Mr. Bean"],
            ["Very big, and still expanding", "93 billion light-years"],
            ["Infinite", "Too long to wait for"],
            [String(randomInteger(0, 9)), "I don't have one"],
            ["We are the world (USA for Africa)", "Heal the world (Michael Jackson)", "Imagine (John Lennon)", "Circle of life (Elton John)"],
            ["Blue as deep as an ocean", "Red as love", "Grass-green", "Snow-white"],
            ["Thousands", "Many", "Countless", "None"],
            ["Thinking", "Being a being", "42"],
        ];
        const label_placeholder_index = randomInteger(0, label_placeholders.length - 1);
        const default_value_placeholders_subset = default_value_placeholders[label_placeholder_index];
        // Create a list of custom variables
        const custom_variable_options = {};
        this.plugin.getCustomVariableInstances().forEach((custom_variable_instance, custom_variable_id) => {
            custom_variable_options[custom_variable_id] = custom_variable_instance.getFullName();
        });
        const on_default_value_setting_change = async (new_default_value) => {
            prompt_field.configuration.default_value = new_default_value;
            await this.plugin.saveSettings();
        };
        // Create the setting fields
        const setting_group_element = container_element.createDiv({ attr: { class: "SC-setting-group" } });
        let label_setting_component;
        let description_setting_component;
        const setting_group = {
            heading_setting: new obsidian.Setting(setting_group_element)
                .setName("") // This will be set down below.
                .setHeading(),
            label_setting: new obsidian.Setting(setting_group_element)
                .setName("Field label")
                .addText(text => label_setting_component = text
                .setValue(prompt_field.configuration.label)
                .setPlaceholder(label_placeholders[label_placeholder_index])
                .onChange(async (new_label) => {
                prompt_field.configuration.label = new_label;
                _update_heading();
                await this.plugin.saveSettings();
            })),
            default_value_setting: new obsidian.Setting(setting_group_element)
                .setName("Default value")
                .addText(text => text
                .setValue(prompt_field.configuration.default_value)
                .setPlaceholder(prompt_field.configuration.label ? "" // If the label is defined, do not add a placeholder here, as the label's placeholder is not visible, so this placeholder would not make sense.
                : default_value_placeholders_subset[randomInteger(0, default_value_placeholders_subset.length - 1)])
                .onChange(on_default_value_setting_change)),
            description_setting: new obsidian.Setting(setting_group_element)
                .setName("Description")
                .addText(text => description_setting_component = text
                .setValue(prompt_field.configuration.description)
                .onChange(async (new_description) => {
                prompt_field.configuration.description = new_description;
                await this.plugin.saveSettings();
            })),
            target_variable_setting: new obsidian.Setting(setting_group_element)
                .setName("Target variable")
                .setDesc("Where the inputted value will be stored in. You can use the variable in a shell command.")
                .addDropdown(dropdown => dropdown
                .addOption("", "") // An option for a situation when nothing is selected.
                .addOptions(custom_variable_options)
                .addOption("new", "Create a new custom variable")
                .setValue(prompt_field.configuration.target_variable_id)
                .onChange((new_target_variable_id) => {
                if ("new" === new_target_variable_id) {
                    // Create a new custom variable.
                    const model = getModel(CustomVariableModel.name);
                    const custom_variable_instance = model.newInstance(this.plugin.settings);
                    this.plugin.saveSettings().then(() => {
                        const modal = new CustomVariableSettingsModal(this.plugin, custom_variable_instance, async () => {
                            // Variable is created.
                            dropdown.addOption(custom_variable_instance.getID(), custom_variable_instance.getTitle());
                            dropdown.setValue(custom_variable_instance.getID());
                            prompt_field.configuration.target_variable_id = custom_variable_instance.getID();
                            await this.plugin.saveSettings();
                        }, async () => {
                            dropdown.setValue(prompt_field.configuration.target_variable_id); // Reset the dropdown selection.
                            // Variable creation was cancelled.
                            model.deleteInstance(custom_variable_instance);
                            await this.plugin.saveSettings();
                        });
                        modal.open();
                    });
                }
                else {
                    // Use an existing target variable (or an empty id "").
                    // Check that this target variable is not reserved.
                    prompt_field.setIfValid("target_variable_id", new_target_variable_id).then(async () => {
                        // It can be used.
                        await this.plugin.saveSettings();
                    }, (error_message) => {
                        if (typeof error_message === "string") {
                            // This is a validation error message.
                            // The target variable is reserved.
                            dropdown.setValue(prompt_field.configuration.target_variable_id); // Reset the dropdown selection.
                            this.plugin.newNotification(error_message);
                        }
                        else {
                            // Some other runtime error has occurred.
                            throw error_message;
                        }
                    });
                }
            })),
            required_setting: new obsidian.Setting(setting_group_element)
                .setName("Is required")
                .setDesc("If on, the field needs to be filled before the prompt can be submitted.")
                .addToggle(toggle => toggle
                .setValue(prompt_field.configuration.required)
                .onChange(async (new_required) => {
                prompt_field.configuration.required = new_required;
                await this.plugin.saveSettings();
            })),
        };
        _update_heading();
        function _update_heading() {
            setting_group.heading_setting.setName(prompt_field.getTitle());
        }
        // Autocomplete menu
        if (this.plugin.settings.show_autocomplete_menu) {
            // Show autocomplete menu (= a list of available variables).
            const label_input_element = setting_group.label_setting.controlEl.find("input");
            createAutocomplete(this.plugin, label_input_element, () => label_setting_component.onChanged());
            const default_value_input_element = setting_group.default_value_setting.controlEl.find("input");
            createAutocomplete(this.plugin, default_value_input_element, on_default_value_setting_change);
            const description_input_element = setting_group.description_setting.controlEl.find("input");
            createAutocomplete(this.plugin, description_input_element, () => description_setting_component.onChanged());
        }
        return setting_group.heading_setting;
    }
    validateValue(prompt_field, field, value) {
        switch (field) {
            case "target_variable_id": {
                const new_target_variable_id = value; // A more descriptive name for 'value'.
                // Always allow an empty target_variable_id. A Prompt cannot be opened if a field lacks a target_variable_id, but it's allowed to be stored in the configuration, because new Prompts cannot have a default selected target variable.
                if ("" === new_target_variable_id) {
                    return Promise.resolve();
                }
                // Check that the target variable is not used by other fields of the same Prompt.
                for (const other_prompt_field of prompt_field.prompt.prompt_fields) {
                    if (prompt_field !== other_prompt_field) { // Do not check the same field. Only check other fields.
                        // Check if this other field has the same target variable.
                        if (new_target_variable_id === other_prompt_field.configuration.target_variable_id) {
                            // They have the same target_variable_id.
                            // Return an error message.
                            const targetVariableInstance = this.plugin.getCustomVariableInstances().get(new_target_variable_id);
                            if (undefined === targetVariableInstance) {
                                throw new Error("Could not find target variable with id " + new_target_variable_id);
                            }
                            const target_variable_name = targetVariableInstance.getFullName();
                            return Promise.reject(`Target variable ${target_variable_name} is already used by another field in the same prompt. Select another variable.`);
                        }
                    }
                }
                // All fields have been checked and no collisions were found.
                return Promise.resolve();
            }
            default: {
                // No validation for other fields.
                throw new Error(this.constructor.name + ".validateValue(): No validation is implemented for other fields.");
            }
        }
    }
    getDefaultConfiguration() {
        return {
            // type: "text",
            label: "",
            description: "",
            default_value: "",
            //  TODO: Add 'placeholder'.
            target_variable_id: "",
            required: true,
        };
    }
    _deleteInstance(prompt_field) {
        prompt_field.prompt.prompt_fields.delete(prompt_field);
    }
}
class PromptFieldSet extends Set {
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class PromptField_Text extends PromptField {
    async _createField(container_element, t_shell_command, sc_event) {
        const plugin = this.prompt.model.plugin;
        // Create the field
        const on_change = () => this.valueHasChanged(t_shell_command, sc_event);
        const label_parsing_result = await parseVariables(this.prompt.model.plugin, this.configuration.label, null, t_shell_command, sc_event);
        const description_parsing_result = await parseVariables(this.prompt.model.plugin, this.configuration.description, null, t_shell_command, sc_event);
        const setting = new obsidian.Setting(container_element)
            .setName(label_parsing_result.succeeded ? label_parsing_result.parsed_content : label_parsing_result.original_content)
            .setDesc(description_parsing_result.succeeded ? description_parsing_result.parsed_content : description_parsing_result.original_content)
            .addText((text_component) => {
            this.text_component = text_component;
            text_component.onChange(on_change);
        });
        // Set up onFocus hook.
        this.text_component.inputEl.onfocus = () => {
            this.hasGottenFocus();
        };
        // Show autocomplete menu (if enabled)
        if (plugin.settings.show_autocomplete_menu) {
            const input_element = setting.controlEl.find("input");
            createAutocomplete(plugin, input_element, on_change);
        }
    }
    setValue(value) {
        this.text_component.setValue(value);
    }
    getValue() {
        return this.text_component.getValue();
    }
    setFocus() {
        this.text_component.inputEl.focus();
    }
    isFilled() {
        return this.getValue().length > 0;
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class Prompt extends Instance {
    constructor(model, plugin, configuration, parent_configuration) {
        super(model, configuration, parent_configuration);
        this.model = model;
        this.plugin = plugin;
        this.configuration = configuration;
        this.parent_configuration = parent_configuration;
        this.prompt_fields = new PromptFieldSet();
        // Introduce the ID to an ID generator so that it won't accidentally generate the same ID again when creating new Prompts.
        getIDGenerator().addReservedID(configuration.id);
        this.createFields();
    }
    getID() {
        return this.configuration.id;
    }
    getTitle() {
        return this.configuration.title;
    }
    getConfiguration() {
        return this.configuration;
    }
    getCSSClass() {
        return Prompt.getCSSBaseClass() + "-" + this.getID();
    }
    static getCSSBaseClass() {
        return "SC-prompt-modal";
    }
    getCSSClasses() {
        return [
            Prompt.getCSSBaseClass(),
            this.getCSSClass(),
        ];
    }
    /**
     * @param t_shell_command Can be null, if wanted to just preview the Prompt modal without really executing a shell command. Inputted values will still be assigned to target variables.
     * @param parsing_process
     * @param sc_event
     * @return Promise The boolean value tells whether the user wants to execute a shell command (true) or cancel (false).
     */
    openPrompt(t_shell_command, parsing_process, sc_event) {
        const can_open_prompt_result = this.canOpenPrompt();
        if (true !== can_open_prompt_result) {
            // Some error is preventing opening the prompt.
            // A human-readable error message is contained in can_open_prompt_result.
            debugLog("Could not open Prompt " + this.getID() + " because of error: " + can_open_prompt_result);
            this.plugin.newError(can_open_prompt_result);
            return Promise.resolve(false); // false: Cancel execution (pretends that a user cancelled it, but it's ok).
        }
        debugLog("Opening Prompt " + this.getID());
        const modal = new PromptModal(this.plugin, this.prompt_fields, t_shell_command, parsing_process, this, sc_event, () => { return this.validateFields(); });
        modal.open();
        return modal.promise;
    }
    canOpenPrompt() {
        // Check that all PromptFields have a target variable defined.
        for (const prompt_field of this.prompt_fields) {
            if (!prompt_field.configuration.target_variable_id) {
                return `Cannot open prompt '${this.getTitle()}': Field '${prompt_field.getTitle()}' does not have a target variable.`;
            }
            else {
                try {
                    prompt_field.getTargetVariableInstance(); // Just try to get a CustomVariableInstance. No need to use it here, but if this fails, we know the variable is removed.
                }
                catch (error) {
                    return `Cannot open prompt '${this.getTitle()}': Field '${prompt_field.getTitle()}' uses a target variable which does not exist anymore.`;
                }
            }
        }
        // All ok.
        return true;
    }
    /**
     * Creates PromptField instances, NOT setting fields!
     */
    createFields() {
        debugLog("Creating fields for Prompt " + this.getID());
        const prompt_field_model = getModel(PromptFieldModel.name);
        this.prompt_fields = prompt_field_model.loadInstances(this);
    }
    /**
     * Validates values in PromptField instances, NOT setting fields!
     */
    validateFields() {
        debugLog("Validating fields for Prompt " + this.getID());
        // Iterate all fields and check their validity.
        const error_messages = [];
        this.prompt_fields.forEach((prompt_field) => {
            // Check if the field has parsing errors.
            const parsing_errors = prompt_field.getParsingErrors();
            for (const parsing_error of parsing_errors) {
                // This field has parsing error(s).
                error_messages.push(`'${prompt_field.getTitle()}': ` + parsing_error);
            }
            // Check other validity.
            if (!prompt_field.validate()) {
                // This field failed to validate.
                // TODO: Change this so that the message will come from prompt_field.validate().
                error_messages.push(`'${prompt_field.getTitle()}' needs to be filled.`);
            }
        });
        // Return the result.
        if (0 === error_messages.length) {
            return Promise.resolve();
        }
        else {
            return Promise.reject(error_messages);
        }
    }
    /**
     * When previewing a PromptModal, there is no real shell command available (because no shell command has triggered the
     * PromptModal). This method creates just a dummy shell command string that imitates a command that would echo variable values.
     */
    getExampleShellCommand() {
        const variable_names = [];
        for (const prompt_field of this.prompt_fields) {
            variable_names.push(prompt_field.getTargetVariableInstance().getFullName());
        }
        return "echo " + variable_names.join(" ");
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class PromptModal extends SC_Modal {
    constructor(plugin, prompt_fields, 
    /** Can be null, if wanted to just preview the Prompt modal without really executing a shell command. Inputted values will still be assigned to target variables. */
    t_shell_command, parsing_process, prompt, sc_event, 
    /** A function that is called when a user clicks the execution button. This function should check the form elements' validity and return false if there are unfilled fields. */
    validator) {
        super(plugin);
        this.prompt_fields = prompt_fields;
        this.t_shell_command = t_shell_command;
        this.parsing_process = parsing_process;
        this.prompt = prompt;
        this.sc_event = sc_event;
        this.validator = validator;
        this.user_confirmed_ok = false;
        this.promise = new Promise((resolve) => {
            this.resolve_promise = resolve;
        });
    }
    async onOpen() {
        super.onOpen();
        // Parse and display title
        const title_parsing_result = await parseVariables(this.plugin, this.prompt.getTitle(), null, this.t_shell_command, this.sc_event);
        this.setTitle(title_parsing_result.succeeded
            ? title_parsing_result.parsed_content
            : title_parsing_result.original_content);
        // Parse and display description
        if (this.prompt.configuration.description) {
            const description_parsing_result = await parseVariables(this.plugin, this.prompt.configuration.description, null, this.t_shell_command, this.sc_event);
            const description = description_parsing_result.succeeded
                ? description_parsing_result.parsed_content
                : description_parsing_result.original_content;
            const description_element = createMultilineTextElement("p", description, this.modalEl);
            description_element.addClass("setting-item-description"); // A CSS class defined by Obsidian.
        }
        // Preview the shell command (if wanted)
        // TODO: Extract to a separate method, as this is a big block of code.
        let update_shell_command_preview = null; // Stays null if .preview_shell_command is false.
        let focused_prompt_field;
        if (this.prompt.getConfiguration().preview_shell_command) {
            let shell_command_preview_text;
            if (this.t_shell_command?.getAlias()) {
                this.modalEl.createEl("p", { text: this.t_shell_command.getAlias(), attr: { class: "SC-no-margin" } });
            }
            // Create "Show variable values" toggle
            let preview_variable_values = true;
            const variable_names_visible_icon = "code-glyph";
            const variable_values_visible_glyph = "price-tag-glyph";
            const preview_variable_values_setting = new obsidian.Setting(this.modalEl)
                .addExtraButton(button => button
                .setIcon(variable_values_visible_glyph)
                .setTooltip("Toggle showing variable names or values.")
                .onClick(() => {
                preview_variable_values = !preview_variable_values;
                button.setIcon(preview_variable_values
                    ? variable_values_visible_glyph
                    : variable_names_visible_icon);
                if (null === update_shell_command_preview) {
                    throw new Error("Toggle showing variable names or value: update_shell_command_preview function is not defined.");
                }
                update_shell_command_preview();
            }));
            // Decide what text to use in the preview
            const shellCommandParsingResult = this.parsing_process?.getParsingResults().shell_command;
            if (shellCommandParsingResult?.succeeded) {
                // Show a real shell command. Use preparsed content (= content that might have some variables already parsed).
                shell_command_preview_text = shellCommandParsingResult.parsed_content; // as string = if shellCommandParsingResult?.succeeded is true, then .parsed_content is always string.
            }
            else if (this.t_shell_command) {
                // Show a real shell command. No preparsed content is available. This content does not have any variables parsed yet.
                shell_command_preview_text = this.t_shell_command.getShellCommand();
            }
            else {
                // Make up a fake "shell command" for previewing.
                shell_command_preview_text = this.prompt.getExampleShellCommand();
                this.modalEl.createEl("p", { text: "(This is not a real shell command, it's just an example for this preview when no real shell command is available.)", attr: { class: "SC-no-margin SC-small-font" } });
            }
            this.modalEl.createEl("hr");
            // A function for handling preview text updates.
            update_shell_command_preview = async () => {
                let shell_command_preview_text_final = shell_command_preview_text;
                if (preview_variable_values) {
                    // The preview should show the VALUES.
                    // Ensure the form fields do not contain any parsing errors. (If there are errors, an unparsed preview text will be shown).
                    if (this.getPromptFieldsParsingErrors().length === 0) {
                        // All fields are parsed ok (= individual parsing).
                        // Insert the field values into the shell command preview by parsing the preview text.
                        // Get current values from the prompt fields.
                        const fresh_values = this.getPromptFieldsValues(); // These PromptField values are fresh, so not yet stored in the actual variables.
                        // Parse variables in the shell command preview text.
                        const parsing_result = await parseVariables(this.plugin, shell_command_preview_text, this.getShell(), this.t_shell_command, this.sc_event, undefined, // Use all variables.
                        (variable, raw_value) => {
                            if (fresh_values.has(variable.variable_name)) {
                                // Change the value to the one in the prompt field.
                                raw_value.error_messages = []; // Remove any possible error messages.
                                raw_value.succeeded = true; // This needs to reflect that there are no error messages.
                                raw_value.value = fresh_values.get(variable.variable_name); // It's always a string because fresh_values.has() is used above.
                            }
                            // No modifications.
                        }, (variable, escaped_value) => {
                            // Emphasize the value that came from the currently focused field.
                            if (focused_prompt_field) {
                                if (variable.variable_name.toLocaleLowerCase() === focused_prompt_field.getTargetVariableInstance().getPrefixedName().toLocaleLowerCase()) {
                                    // Make the value bold.
                                    return `<strong>${escaped_value}</strong>`;
                                }
                            }
                            // No modifications.
                            return escaped_value;
                        });
                        if (parsing_result.succeeded) {
                            shell_command_preview_text_final = parsing_result.parsed_content;
                        }
                    }
                }
                else {
                    // The preview should show the VARIABLE NAMES.
                    if (focused_prompt_field) {
                        const pattern = new RegExp(focused_prompt_field.getTargetVariable().getPattern(), "igu"); // i: case-insensitive; g: match all occurrences instead of just the first one. u: support 4-byte unicode characters too.
                        shell_command_preview_text_final = shell_command_preview_text_final.replace(pattern, (replaceable_variable_name) => {
                            return "<strong>" + replaceable_variable_name + "</strong>";
                        });
                    }
                }
                preview_variable_values_setting.descEl.innerHTML = shell_command_preview_text_final;
            };
        }
        // Create fields
        let is_first_field = true;
        for (const prompt_field of this.prompt_fields) {
            await prompt_field.createField(this.modalEl.createDiv({ attr: { class: "SC-setting-group" } }), this.t_shell_command, this.sc_event);
            if (update_shell_command_preview) {
                prompt_field.onChange(update_shell_command_preview);
            }
            prompt_field.onFocus((prompt_field) => {
                focused_prompt_field = prompt_field;
                if (update_shell_command_preview) {
                    update_shell_command_preview();
                }
            });
            if (is_first_field) {
                // Focus on the first field.
                is_first_field = false;
                prompt_field.setFocus();
            }
        }
        if (update_shell_command_preview) {
            // Set a preview text. Must be done after fields are created, because their values are accessed.
            update_shell_command_preview();
        }
        // Tip about variables
        let tip = "";
        if (this.prompt_fields.size > 0) {
            // TODO: When implementing different field types, add a check that the tip is only shown when there are text/numeric fields present.
            // Only show the tip if this modal actually contains fields. Prompts can also be used as custom 'confirmation prompts' without any fields.
            tip = "Tip! You can use {{variables}} in text fields.";
        }
        // Execute button
        const execute_button_text_parsing_result = await parseVariables(this.plugin, this.prompt.configuration.execute_button_text, null, this.t_shell_command, this.sc_event);
        const execute_button_text = execute_button_text_parsing_result.succeeded
            ? execute_button_text_parsing_result.parsed_content
            : execute_button_text_parsing_result.original_content;
        new obsidian.Setting(this.modalEl)
            .setDesc(tip)
            .addButton(button => button
            .setButtonText(execute_button_text)
            .onClick(() => this.approve()));
        if (!this.t_shell_command) {
            // Notice that this is a preview only Prompt.
            this.modalEl.createEl("p", { text: `This is a preview prompt. No shell command will be executed, but clicking the '${this.prompt.configuration.execute_button_text}' button will still store the inputted value(s) to variable(s).` }).addClass("SC-prompt-dry-run-notice");
        }
        // Add CSS classes so that custom styling can be done on a per-prompt modal basis (or for all prompt modals via a common class).
        this.modalEl.addClasses(this.prompt.getCSSClasses());
    }
    approve() {
        this.validator().then(async () => {
            // The form fields are filled ok
            await this.assignValuesToVariables();
            this.resolve_promise(true);
            this.user_confirmed_ok = true;
            this.close();
        }, (error_messages) => {
            if (Array.isArray(error_messages)) {
                // There were some problems with the fields.
                this.plugin.newErrors(error_messages);
            }
            else {
                // Some other runtime error has occurred.
                throw error_messages;
            }
        });
    }
    onClose() {
        super.onClose();
        if (!this.user_confirmed_ok) { // TODO: Find out if there is a way to not use this kind of flag property. Can the status be checked from the promise itself?
            this.resolve_promise(false);
        }
    }
    async assignValuesToVariables() {
        let promptField;
        for (promptField of this.prompt_fields) {
            await promptField.getTargetVariable().setValue(promptField.getParsedOrRawValue());
        }
    }
    /**
     * Gathers a Map of variable values typed in the form, but does not store the values into the variables. Called when
     * generating a preview text, so the result of this method will not persist in any way.
     * @private
     */
    getPromptFieldsValues() {
        const values = new Map();
        for (const prompt_field of this.prompt_fields) {
            values.set(prompt_field.getTargetVariable().variable_name, prompt_field.getParsedValue() ?? ""); // TODO: Should getParsedValue() ?? "" be changed to getParsedOrRawValue(), too?
        }
        return values;
    }
    getPromptFieldsParsingErrors() {
        const parsing_errors = [];
        for (const prompt_field of this.prompt_fields) {
            parsing_errors.push(...prompt_field.getParsingErrors());
        }
        return parsing_errors;
    }
    getShell() {
        if (this.t_shell_command) {
            // This is a real usage of the PromptModal, so a TShellCommand is available. Look up the shell from that.
            return this.t_shell_command.getShell();
        }
        else {
            // Just trying the PromptModal. Just use some shell for variable escaping in an example preview.
            return this.plugin.getDefaultShell();
        }
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class PromptModel extends Model {
    constructor() {
        super(...arguments);
        this.prompts = new PromptMap();
    }
    getSingularName() {
        return "Prompt";
    }
    defineParentConfigurationRelation(prompt) {
        return {
            type: "one-to-many-id",
            key: "prompts",
            id: prompt.getID(),
        };
    }
    loadInstances(parent_configuration) {
        debugLog("Loading Prompt instances.");
        this.prompts = new PromptMap();
        parent_configuration.prompts.forEach((prompt_configuration) => {
            const prompt = new Prompt(this, this.plugin, prompt_configuration, parent_configuration);
            this.prompts.set(prompt_configuration.id, prompt);
        });
        return this.prompts;
    }
    newInstance(parent_configuration) {
        debugLog("Creating a new Prompt instance.");
        // TODO: Move this logic to the base Model class.
        // Setup a default configuration and generate an ID
        const prompt_configuration = this.getDefaultConfiguration();
        // Instantiate a Prompt
        const prompt = new Prompt(this, this.plugin, prompt_configuration, this.plugin.settings);
        this.prompts.set(prompt.getID(), prompt);
        // Store the configuration into plugin's settings
        this.plugin.settings.prompts.push(prompt_configuration);
        // Return the Prompt
        return prompt;
    }
    _createSettingFields(prompt, container_element) {
        debugLog("Creating setting fields for a Prompt instance.");
        const prompt_name_setting = new obsidian.Setting(container_element)
            // Configuration button
            .setName(prompt.getTitle())
            .addExtraButton(button => button
            .setTooltip("Define prompt fields")
            .setIcon("gear")
            .onClick(() => {
            this.openSettingsModal(prompt, prompt_name_setting);
        }));
        return prompt_name_setting;
    }
    validateValue(prompt, field, value) {
        // This method is not used, so it can just resolve all the time.
        return Promise.resolve(undefined);
    }
    openSettingsModal(prompt, prompt_name_setting) {
        debugLog("Opening settings modal for a Prompt instance.");
        const modal = new PromptSettingsModal(this.plugin, prompt, prompt_name_setting);
        modal.open();
    }
    getDefaultConfiguration() {
        return {
            id: getIDGenerator().generateID(),
            title: "",
            description: "",
            preview_shell_command: false,
            fields: [],
            execute_button_text: "Execute",
        };
    }
    _deleteInstance(prompt) {
        debugLog("Deleting a Prompt instance.");
        // Remove the Prompt from all TShellCommands that use it.
        const shell_commands = this.plugin.getTShellCommands();
        for (const shell_command_id in shell_commands) {
            const t_shell_command = shell_commands[shell_command_id];
            for (const preaction_configuration of t_shell_command.getConfiguration().preactions) {
                if ("prompt" === preaction_configuration.type) {
                    const preaction_prompt_configuration = preaction_configuration;
                    if (prompt.getID() === preaction_prompt_configuration.prompt_id) {
                        // This TShellCommand uses this Prompt.
                        // Remove the Prompt from use.
                        preaction_prompt_configuration.enabled = false;
                        preaction_prompt_configuration.prompt_id = undefined;
                        t_shell_command.resetPreactions();
                        // Saving is done later, after the _deleteInstance() call.
                    }
                }
            }
        }
        this.prompts.delete(prompt.getID());
    }
}
class PromptMap extends Map {
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * @return Promise<InstanceClass> A promise that gets resolved if a user clicks the button. The promise is supplied with the newly created instance.
 */
function createNewModelInstanceButton(plugin, model_class_name, button_container_element, instance_container_element, parent_instance_or_configuration) {
    debugLog("Creating a button for creating a new instance for model " + model_class_name + ".");
    return new Promise((resolve_promise) => {
        const model = getModel(model_class_name);
        new obsidian.Setting(button_container_element)
            .addButton(button => button
            .setButtonText("New " + model.getSingularName().toLocaleLowerCase())
            .onClick(async () => {
            if (null === parent_instance_or_configuration) {
                throw new Error("createNewModelInstanceButton(): Parent instance or configuration is null.");
            }
            const instance = model.newInstance(parent_instance_or_configuration);
            const main_setting = model.createSettingFields(instance, instance_container_element);
            resolve_promise({
                "instance": instance,
                "main_setting": main_setting,
            });
            await plugin.saveSettings();
        }));
    });
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class PromptSettingsModal extends SC_Modal {
    constructor(plugin, prompt, 
    /** Can be undefined if the modal is created from a place where there is no name element. */
    prompt_name_setting, 
    /** If defined, a button will be added and on_after_approval() / on_after_cancelling() will be called depending on whether the button was clicked or not. */
    ok_button_text, on_after_approval, on_after_cancelling) {
        super(plugin);
        this.prompt = prompt;
        this.prompt_name_setting = prompt_name_setting;
        this.ok_button_text = ok_button_text;
        this.on_after_approval = on_after_approval;
        this.on_after_cancelling = on_after_cancelling;
        this.approved = false;
    }
    onOpen() {
        super.onOpen();
        const container_element = this.modalEl;
        const title_and_description_group_element = container_element.createDiv({ attr: { class: "SC-setting-group" } });
        // Title
        const title_setting = new obsidian.Setting(title_and_description_group_element)
            .setName("Prompt title")
            .addExtraButton(icon => icon
            .setTooltip("Try the prompt without executing any shell command.")
            .setIcon("run-command")
            .onClick(() => {
            // "Dry run" the Prompt
            this.prompt.openPrompt(null, null, null).then();
        }))
            .addText(text => text
            .setValue(this.prompt.getTitle())
            .onChange(async (new_title) => {
            this.prompt.getConfiguration().title = new_title;
            await this.plugin.saveSettings();
            // Update the title in a name setting. (Only if the modal was created from a place where a Prompt name element exists).
            this.prompt_name_setting?.setName(new_title);
        })
            .then((title_setting_component) => {
            // Autocomplete for Title.
            if (this.plugin.settings.show_autocomplete_menu) {
                createAutocomplete(this.plugin, title_setting_component.inputEl, () => title_setting_component.onChanged());
            }
        }));
        const title_input_element = title_setting.controlEl.find("input");
        // Focus on the title field.
        title_input_element.focus();
        // Description
        new obsidian.Setting(title_and_description_group_element)
            .setName("Description")
            .setDesc("Displayed between the prompt title and fields. Both Description and Title support {{variables}}.")
            .addTextArea(textarea => textarea
            .setValue(this.prompt.configuration.description)
            .onChange(async (new_description) => {
            this.prompt.getConfiguration().description = new_description;
            await this.plugin.saveSettings();
        })
            .then((description_component) => {
            // Autocomplete for Description.
            if (this.plugin.settings.show_autocomplete_menu) {
                createAutocomplete(this.plugin, description_component.inputEl, () => description_component.onChanged());
            }
        }));
        // Preview shell command
        new obsidian.Setting(container_element)
            .setName("Preview shell command in prompt")
            .setDesc("If this is on, the prompt will display the executable shell command with variable names in it, and highlight the variable(s) that will be affected by the values inputted in the prompt.")
            .addToggle(toggle => toggle
            .setValue(this.prompt.getConfiguration().preview_shell_command)
            .onChange(async (new_value) => {
            this.prompt.getConfiguration().preview_shell_command = new_value;
            await this.plugin.saveSettings();
        }));
        // Fields
        new obsidian.Setting(container_element)
            .setName("Fields")
            .setDesc("Tip! You can use {{variables}} in 'Field label', 'Default value' and 'Description'.");
        const prompt_field_model = getModel(PromptFieldModel.name);
        const fields_container = container_element.createDiv();
        this.prompt.prompt_fields.forEach((prompt_field) => {
            prompt_field_model.createSettingFields(prompt_field, fields_container);
        });
        // New field button
        createNewModelInstanceButton(this.plugin, PromptFieldModel.name, container_element, fields_container, this.prompt).then();
        // Execute button text
        new obsidian.Setting(container_element.createDiv({ attr: { class: "SC-setting-group" } }))
            .setName("Execute button text")
            .addText(text => text
            .setValue(this.prompt.configuration.execute_button_text)
            .onChange(async (new_execute_button_text) => {
            this.prompt.configuration.execute_button_text = new_execute_button_text;
            await this.plugin.saveSettings();
        })
            .then((execute_button_text_component) => {
            // Autocomplete for the Execute button text.
            if (this.plugin.settings.show_autocomplete_menu) {
                createAutocomplete(this.plugin, execute_button_text_component.inputEl, () => execute_button_text_component.onChanged());
            }
        }));
        // Ok button
        const okButtonText = this.ok_button_text;
        if (okButtonText) {
            new obsidian.Setting(container_element)
                .addButton(button => button
                .setButtonText(okButtonText)
                .onClick(() => this.approve()));
        }
        // A tip about CSS styling.
        new obsidian.Setting(container_element)
            .setDesc("Tip! You can customise the style of the prompt modal with CSS by using the class ." + this.prompt.getCSSClass() + " or ." + Prompt.getCSSBaseClass() + " (for all prompt modals).");
    }
    approve() {
        if (this.on_after_approval) {
            this.approved = true;
            this.on_after_approval();
        }
        this.close();
    }
    onClose() {
        super.onClose();
        // Call a cancelling hook if one is defined (and if the closing happens due to cancelling, i.e. the ok button is NOT clicked).
        if (!this.approved && this.on_after_cancelling) {
            this.on_after_cancelling();
        }
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function createPATHAugmentationFields(plugin, container_element, path_augmentations) {
    const path_variable_name = getPATHEnvironmentVariableName();
    new obsidian.Setting(container_element)
        .setName(`Add directories to the ${path_variable_name} environment variable`)
        .setHeading()
        .setDesc(`This is sometimes needed in order to be able to call some user installed applications. The directories will be appended AFTER the default directories in ${path_variable_name}, unless {{!environment:${path_variable_name}}} is included. Other {{variables}} can be used, too, but they don't affect the appending order.`)
        // An icon for showing the current PATH content.
        .addExtraButton(button => button
        .setIcon("bullet-list")
        .setTooltip(`Show the current ${path_variable_name} content (without any additions).`)
        .onClick(() => {
        if (undefined === process.env.PATH) {
            throw new Error("process.env.PATH is not a string.");
        }
        const modal = new ConfirmationModal(plugin, `Current ${path_variable_name} content`, process.env.PATH, "Close");
        modal.open();
    }))
        // Help link
        .addExtraButton(button => button
        .setIcon("help")
        .setTooltip(`Documentation: Additions to the ${path_variable_name} environment variable`)
        .onClick(() => gotoURL(DocumentationPATHAugmentationsLink)));
    // Create a field for each operating system.
    const sub_container_element = container_element.createDiv();
    sub_container_element.addClass("SC-setting-group");
    Object.getOwnPropertyNames(PlatformNames).forEach((platform_id) => {
        const platform_name = PlatformNames[platform_id];
        new obsidian.Setting(sub_container_element).setName(platform_name + " " + getPATHEnvironmentVariableName(platform_id) + " additions")
            .setDesc("Define each directory on a separate line, or multiple directories on one line, separated by " + getPATHSeparator(platform_id, true))
            .addTextArea(textarea => textarea
            .setValue(path_augmentations[platform_id] ?? "")
            .onChange(async (new_path_augmentation) => {
            // PATH augmentation has been changed.
            // Update the configuration.
            if (new_path_augmentation.length > 0) {
                // The augmentation has content.
                path_augmentations[platform_id] = new_path_augmentation;
            }
            else {
                // The augmentation has been removed.
                delete path_augmentations[platform_id];
            }
            await plugin.saveSettings();
        })
            .then((textarea_component) => {
            // Add an autocomplete menu.
            createAutocomplete(plugin, textarea_component.inputEl, () => textarea_component.onChanged());
        }));
    });
}
function getPATHSeparator(platform_id, verbose = false) {
    switch (platform_id) {
        case "linux":
        case "darwin": // This is macOS.
            return verbose ? "a colon :" : ":";
        case "win32":
            return verbose ? "a semicolon ;" : ";";
    }
}
function convertNewlinesToPATHSeparators(path, platform_id) {
    const separator = getPATHSeparator(platform_id);
    return path.replace(/(\r\n|\r|\n)+/gu, // + means that multiple adjacent newlines can be combined into a single separator character.
    () => separator);
}
/**
 * Retrieves a PATH environment variable augmentation string (specific to the current operating system) from the plugin's
 * configuration. Returns it WITHOUT parsing possible variables in the string. If the current operating system does not
 * have a dedicated PATH augmentation string in the configuration, returns null.
 *
 * @param plugin
 */
function getPATHAugmentation(plugin) {
    return plugin.settings.environment_variable_path_augmentations[getOperatingSystem()] ?? null;
}
/**
 * Returns OS specific name for the PATH environment variable. For Windows its Path, but for macOS and Linux its PATH, so
 * the only difference is casing.
 */
function getPATHEnvironmentVariableName(platform_id = getOperatingSystem()) {
    switch (platform_id) {
        case "darwin":
        case "linux":
            return "PATH";
        case "win32":
            return "Path";
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * ParsingProcess instances can be used in situations where it's uncertain can all variables be parsed at the time being,
 * i.e. when parsing shell commands (and aliases), as they can have preactions which require parsing to be done in two phases.
 *
 * Also, shell commands are often parsed in advance for command palette and context menus. Then it's good to store the parsing
 * result by using instances of this class.
 *
 * Then again, if the parsing use-case is simpler, e.g. Prompt description or prompt field values, it's more straightforward
 * to just call parseVariables() without utilising this class. After all, this class is a wrapper for parseVariables().
 *
 * <ParsingMap> is a generalization for defining keys for an object that will be used for submitting the original parseable
 * content. The same keys will then be used to form another object containing the parsing results.
 */
class ParsingProcess {
    constructor(plugin, original_contents, 
    /** Used to get a shell (getShell()) and default values for variables. */
    t_shell_command, sc_event, 
    /**
     * When .process() is called, it will shift and process the first VariableSet present in this array. So, the next call
     * will shift and process the next set.
     */
    variable_sets, 
    /**
     * This can be used to mark certain contents to always avoid escaping special characters in their variable values.
     * This should only be used for content that is never submitted to a shell, i.e. output wrappers at the moment.
     *
     * This is a list of 'content keys'.
     */
    avoid_escaping = []) {
        this.plugin = plugin;
        this.original_contents = original_contents;
        this.t_shell_command = t_shell_command;
        this.sc_event = sc_event;
        this.variable_sets = variable_sets;
        this.avoid_escaping = avoid_escaping;
        this.parsing_results = {};
        this.is_first_call = true;
        debugLog("Parsing process: Count variable sets: " + this.variable_sets.length);
    }
    /**
     * Performs the next step in the parsing process. The step can be the first one, or a subsequent step.
     *
     * @return True if parsing succeeded, false otherwise. Read the results by calling .getParsingResult().
     */
    async process() {
        if (this.variable_sets.length === 0) {
            throw new Error("No variable sets are left for processing.");
        }
        const current_variables = this.variable_sets.shift(); // as VariableSet: Tell TypeScript that there is always a set of variables.
        let success = true;
        debugLog("Parsing process: Count variables in current set: " + current_variables.size);
        // Multiple contents can be parsed in the same call. TShellCommand instances have 'shell_command' and 'alias'
        // contents which are parsed at the same time. This multi-content support can be used for even more situations if
        // needed in the future.
        for (const content_key of this.getContentKeys()) {
            let parse_content;
            if (this.is_first_call) {
                // Use original content.
                parse_content = this.original_contents[content_key];
                debugLog("Starting to parse '" + content_key + "': " + parse_content);
            }
            else {
                // Continue parsing content from previous parsing result. This time parse variables that were not parse back then.
                // FIXME: Problem: variable values that came from an earlier phase are exposed to repetitive parsing. Find a way to limit the parsing to only original parts of the shell command.
                const previousParsingResult = this.parsing_results[content_key];
                if (undefined === previousParsingResult) {
                    // This is just a type guard. this.getContentKeys() should only return keys that exist, so the checks should never throw errors in practise.
                    throw new Error("Parsing results do not contain key: " + content_key);
                }
                // Check that the previous parsing did not fail.
                if (null === previousParsingResult.parsed_content) {
                    // Previous parsing had probably failed.
                    throw new Error("Tried to continue parsing, but previous parsing result is null. Probably previous parsing has failed.");
                }
                // Previous parsing was ok.
                parse_content = previousParsingResult.parsed_content;
                debugLog("Continuing parsing '" + content_key + "': " + parse_content);
            }
            // Parse the variables
            const parsing_result = await parseVariables(this.plugin, parse_content, this.avoidEscaping(content_key) ? null : this.t_shell_command.getShell(), // If no escaping is needed, pass null.
            this.t_shell_command, this.sc_event, current_variables);
            // Check if the parsing succeeded or failed.
            success = success && parsing_result.succeeded; // Flag as failed also if a previous phase has failed.
            // Store the parsing result
            this.mergeToParsingResults(content_key, parsing_result);
        }
        // Finish
        this.is_first_call = false;
        return success;
    }
    /**
     * A wrapper for .process() that processes all the VariableSets that are still left unprocessed.
     *
     * @return True if parsing all sets succeeded, false otherwise.
     */
    async processRest() {
        // 1. Check a previous parsing result (if exists).
        for (const content_key of this.getContentKeys()) {
            const parsingResult = this.parsing_results[content_key];
            if (parsingResult) {
                // A previous parsing result exists.
                // Ensure it has not failed.
                debugLog("Previous parsing succeeded? " + parsingResult.succeeded);
                if (!parsingResult.succeeded) {
                    // The previous parsing result has failed.
                    return false;
                }
            }
        }
        // 2. Process the rest of the VariableSets.
        for (let i = 0; i < this.variable_sets.length; i++) {
            if (!await this.process()) {
                return false;
            }
        }
        return true;
    }
    getParsingResults() {
        return this.parsing_results;
    }
    /**
     * Calls SC_Plugin.newErrors() to create visible error balloons for all the issues encountered during parsing.
     */
    displayErrorMessages() {
        this.plugin.newErrors(this.getErrorMessages());
    }
    /**
     * @private Can be made public if needed.
     */
    getErrorMessages() {
        let error_messages = [];
        for (const content_key of this.getContentKeys()) {
            const parsingResult = this.parsing_results[content_key];
            // Type guard
            if (undefined === parsingResult) {
                // This should never happen, because this.getContentKeys() should only return existing keys.
                throw new Error("Parsing result is undefined.");
            }
            error_messages.push(...parsingResult.error_messages);
        }
        // Remove duplicate error messages. When parsing 'shell_command' and 'alias', they can contain same variables and
        // therefore generate same error messages.
        error_messages = uniqueArray(error_messages);
        return error_messages;
    }
    getContentKeys() {
        return Object.getOwnPropertyNames(this.original_contents);
    }
    /**
     * Merges consecutive parsing results together so that information from both the old and new parsing results can be preserved.
     */
    mergeToParsingResults(content_key, newParsingResult) {
        const originalParsingResult = this.parsing_results[content_key];
        if (undefined === originalParsingResult) {
            // No need to merge. But clone the object so that possible future merges will not mess up the original object
            // in case it's used somewhere else.
            this.parsing_results[content_key] = cloneObject(newParsingResult);
            // Note that originalParsingResult is still undefined. If you continue writing code here or after the if block
            // (near the end of the function), do something like originalParsingResult = this.parsing_results[content_key]
            // but that would require changing originalParsingResult from const to let.
        }
        else {
            // Merge
            // NOTE: originalParsingResult.original_content IS KEPT UNCHANGED! The newer "original" content is not actually original, because it's partly parsed. That's why the old one is preserved.
            originalParsingResult.parsed_content = newParsingResult.parsed_content; // New parsed content overrides the old one.
            originalParsingResult.succeeded &&= newParsingResult.succeeded; // Both the old and new parsing must have succeeded in order to consider the whole process succeeded.
            originalParsingResult.error_messages.push(...newParsingResult.error_messages); // Include both old and new error messages.
            originalParsingResult.count_parsed_variables += newParsingResult.count_parsed_variables; // Sum up the variable usage counts. At the time of writing, the sum is only used for determining if there were any variables parsed or not, so an accurate sum is not used atm.
        }
    }
    /**
     * Tells whether the given content_key has a mark that special characters in the content's variable values should not be escaped.
     *
     * @param content_key
     * @private
     */
    avoidEscaping(content_key) {
        return this.avoid_escaping.contains(content_key);
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function newShellCommandConfiguration(shell_command_id, shell_command = "") {
    return {
        id: shell_command_id,
        platform_specific_commands: {
            default: shell_command,
        },
        shells: {},
        alias: "",
        icon: null,
        confirm_execution: false,
        ignore_error_codes: [],
        input_contents: {
            stdin: null,
        },
        output_channels: {
            stdout: "ignore",
            stderr: "notification",
        },
        output_wrappers: {
            stdout: null,
            stderr: null,
        },
        output_channel_order: "stdout-first",
        output_handling_mode: "buffered",
        events: {},
        command_palette_availability: "enabled",
        preactions: [],
        variable_default_values: {},
    };
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
async function RunMigrations(plugin) {
    const should_save = [
        EnsureMainFieldsExist(plugin),
        MigrateCommandsToShellCommands(plugin),
        MigrateShellCommandsObjectToArray(plugin),
        MigrateShellCommandToPlatforms(plugin),
        EnsureShellCommandsHaveAllFields(plugin),
        EnsureCustomVariablesHaveAllFields(plugin),
        DeleteEmptyCommandsField(plugin),
    ];
    if (should_save.includes(true)) {
        // Only save if there were changes to configuration.
        debugLog("Saving migrations...");
        backupSettingsFile(plugin); // Make a backup copy of the old file BEFORE writing the new, migrated settings file.
        await plugin.saveSettings();
        debugLog("Migrations saved...");
    }
}
/**
 * Can be removed in the future, but I haven't yet decided will it be done in 1.0 or later.
 */
function MigrateShellCommandsObjectToArray(plugin) {
    // Check if the shell commands' container is an object.
    if (!Array.isArray(plugin.settings.shell_commands)) {
        // It is an object. It needs to be changed to an array in order to allow custom ordering.
        const shell_commands_array = [];
        for (const shell_command_id of Object.getOwnPropertyNames(plugin.settings.shell_commands)) { // Remember that plugin.settings.shell_commands is an object here! Not an array (yet).
            // @ts-ignore I don't know why TypeScript thinks the index is incorrect.
            const shell_command_configuration = plugin.settings.shell_commands[shell_command_id];
            // Assign 'id' to ShellCommandConfiguration because it did not contain it before this migration.
            shell_command_configuration.id = shell_command_id;
            // Add the ShellCommandConfiguration to the new array container.
            shell_commands_array.push(shell_command_configuration);
        }
        // Replace the old object container with the new array container.
        plugin.settings.shell_commands = shell_commands_array; // Now plugin.settings.shell_commands changes to be an array instead of an object.
        return true; // Save the changes.
    }
    else {
        // The container is already migrated.
        return false; // No need to save anything.
    }
}
/**
 * Can be removed in 1.0.0.
 *
 * @param plugin
 * @constructor
 */
function MigrateCommandsToShellCommands(plugin) {
    if (undefined === plugin.settings.commands) {
        return false;
    }
    const count_shell_commands = plugin.settings.commands.length;
    let save = false;
    if (0 < count_shell_commands) {
        let count_empty_commands = 0; // A counter for empty or null commands
        debugLog("settings.commands is not empty, will migrate " + count_shell_commands + " commands to settings.shell_commands.");
        for (const shell_command_id in plugin.settings.commands) {
            const shell_command = plugin.settings.commands[shell_command_id];
            // Ensure that the command is not empty. Just in case.
            if (null === shell_command || 0 === shell_command.length) {
                // The command is empty
                debugLog("Migration failure for shell command #" + shell_command_id + ": The original shell command string is empty, so it cannot be migrated.");
                count_empty_commands++;
            }
            else if (undefined !== plugin.getShellCommandConfigurationIndex(shell_command_id)) {
                // A command with the same id already exists
                debugLog("Migration failure for shell command #" + shell_command_id + ": A shell command with same ID already exists in settings.shell_commands.");
            }
            else {
                // All OK, migrate.
                plugin.settings.shell_commands.push(newShellCommandConfiguration(shell_command_id, shell_command)); // Creates a shell command with default values and defines the command for it.
                delete plugin.settings.commands[shell_command_id]; // Leaves a null in place, but we can deal with it by deleting the whole array if it gets empty.
                count_empty_commands++; // Account the null generated on the previous line.
                save = true;
                debugLog("Migrated shell command #" + shell_command_id + ": " + shell_command);
            }
        }
        if (count_empty_commands === count_shell_commands) {
            // The whole commands array now contains only empty/null commands.
            // Delete it.
            delete plugin.settings.commands;
        }
    }
    else {
        debugLog("settings.commands is empty, so no need to migrate commands. Good thing! :)");
    }
    return save;
}
/**
 * This is a general migrator that adds new, missing properties to ShellCommandConfiguration objects. This is not tied to any specific version update, unlike MigrateCommandsToShellCommands().
 *
 * @param plugin
 * @constructor
 */
function EnsureShellCommandsHaveAllFields(plugin) {
    let save = false;
    const shell_command_default_configuration = newShellCommandConfiguration("no-id"); // Use a dummy id here, because something needs to be used. This id should never end up being used in practice.
    const shell_command_configurations = plugin.settings.shell_commands;
    for (const shell_command_configuration of shell_command_configurations) {
        for (const property_name in shell_command_default_configuration) {
            // @ts-ignore property_default_value can have (almost) whatever datatype
            const property_default_value = shell_command_default_configuration[property_name];
            // @ts-ignore
            if (undefined === shell_command_configuration[property_name] && property_name !== "id") { // The "id" check is just in case that MigrateShellCommandsObjectToArray() would not have added the "id" property, in which case the dummy "no-id" id should not be accidentally assigned to the shell command.
                // This shell command does not have this property.
                // Add the property to the shell command and use a default value.
                debugLog("EnsureShellCommandsHaveAllFields(): Shell command #" + shell_command_configuration.id + " does not have a property '" + property_name + "'. Will create the property and assign a default value '" + property_default_value + "'.");
                // @ts-ignore
                shell_command_configuration[property_name] = property_default_value;
                save = true;
            }
        }
    }
    return save;
}
function EnsureCustomVariablesHaveAllFields(plugin) {
    let save = false;
    const customVariableModel = getModel(CustomVariableModel.name);
    const customVariableDefaultConfiguration = customVariableModel.getDefaultConfiguration();
    let customVariableConfiguration;
    for (customVariableConfiguration of plugin.settings.custom_variables) {
        for (const propertyName in customVariableDefaultConfiguration) {
            // @ts-ignore propertyDefaultValue can have (almost) whatever datatype
            const propertyDefaultValue = customVariableDefaultConfiguration[propertyName];
            // @ts-ignore
            if (undefined === customVariableConfiguration[propertyName]) {
                // This custom variable does not have this property.
                // Add the property to it and use a default value.
                debugLog("EnsureCustomVariablesHaveAllFields(): Custom variable #" + customVariableConfiguration.id + " does not have a property '" + propertyName + "'. Will create the property and assign a default value '" + propertyDefaultValue + "'.");
                // @ts-ignore
                customVariableConfiguration[propertyName] = propertyDefaultValue;
                save = true;
            }
        }
    }
    return save;
}
/**
 * This is a general migrator that adds new, missing properties to the main settings object. This is not tied to any specific version update, unlike MigrateCommandsToShellCommands().
 *
 * @param plugin
 * @constructor
 */
function EnsureMainFieldsExist(plugin) {
    let has_missing_fields = false;
    const settings = plugin.settings;
    const default_settings = getDefaultSettings(false);
    for (const property_name in default_settings) {
        // @ts-ignore
        if (undefined === settings[property_name]) {
            // The settings object does not have this property.
            // @ts-ignore property_default_value can have (almost) whatever datatype
            const property_default_value = default_settings[property_name];
            debugLog("EnsureMainFieldsExist(): Main settings does not have property '" + property_name + "'. Will later create the property and assign a default value '" + property_default_value + "'.");
            has_missing_fields = true;
        }
    }
    if (has_missing_fields) {
        debugLog("EnsureMainFieldsExist(): Doing the above-mentioned new field creations...");
        plugin.settings = combineObjects(default_settings, plugin.settings);
        debugLog("EnsureMainFieldsExist(): Done.");
        return true; // Save the changes
    }
    debugLog("EnsureMainFieldsExist(): No new fields to create, all ok.");
    return false; // Nothing to save.
}
/**
 * Can be removed in 1.0.0.
 *
 * @param plugin
 * @constructor
 */
function MigrateShellCommandToPlatforms(plugin) {
    let save = false;
    for (const shell_command_configuration of plugin.settings.shell_commands) {
        if (undefined !== shell_command_configuration.shell_command) {
            // The shell command should be migrated.
            if (undefined === shell_command_configuration.platform_specific_commands || shell_command_configuration.platform_specific_commands.default === "") {
                debugLog("Migrating shell command #" + shell_command_configuration.id + ": shell_command string will be moved to platforms.default: " + shell_command_configuration.shell_command);
                shell_command_configuration.platform_specific_commands = {
                    default: shell_command_configuration.shell_command,
                };
                delete shell_command_configuration.shell_command;
                save = true;
            }
            else {
                debugLog("Migration failure for shell command #" + shell_command_configuration.id + ": platforms exists already.");
            }
        }
    }
    return save;
}
/**
 * Can be removed in 1.0.0.
 *
 * @param plugin
 * @constructor
 */
function DeleteEmptyCommandsField(plugin) {
    let save = false;
    if (undefined !== plugin.settings.commands) {
        if (plugin.settings.commands.length === 0) {
            delete plugin.settings.commands;
            save = true;
        }
    }
    return save;
}
/**
 * Permanent, do not remove.
 *
 * @param plugin
 */
function backupSettingsFile(plugin) {
    // plugin.app.fileManager.
    // @ts-ignore
    const current_settings_version = (plugin.settings.settings_version === "prior-to-0.7.0") ? "0.x" : plugin.settings.settings_version;
    const plugin_path = getPluginAbsolutePath(plugin);
    const settings_file_path = path__namespace.join(plugin_path, "data.json");
    const backup_file_path_without_extension = path__namespace.join(plugin_path, "data-backup-version-" + current_settings_version + "-before-upgrading-to-" + SC_Plugin.SettingsVersion);
    // Check that the current settings file can be found.
    if (!fs__namespace.existsSync(settings_file_path)) {
        // Not found. Probably the vault uses a different config folder than .obsidian.
        debugLog("backupSettingsFile(): Cannot find data.json");
        plugin.newError("Shell commands: Cannot create a backup of current settings file, because data.json is not found.");
        return;
    }
    let backup_file_path = backup_file_path_without_extension + ".json";
    let running_number = 1;
    while (fs__namespace.existsSync(backup_file_path)) {
        running_number++; // The first number will be 2.
        backup_file_path = backup_file_path_without_extension + "-" + running_number + ".json";
        if (running_number >= 1000) {
            // There is some problem with detecting existing/inexisting files.
            // Prevent hanging the program in an eternal loop.
            throw new Error("backupSettingsFile(): Eternal loop detected.");
        }
    }
    fs__namespace.copyFileSync(settings_file_path, backup_file_path);
}
// TODO: Add migration: shell command variable_default_values: if type is "show-errors", change it to "inherit", but only if old settings version was below 18.

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function createShellSelectionField(plugin, container_element, shells, is_global_settings) {
    let platform_id;
    for (platform_id in PlatformNames) {
        const platform_name = PlatformNames[platform_id];
        let options;
        if (is_global_settings) {
            const current_system_default = (getOperatingSystem() === platform_id) ? " (" + extractFileName(getUsersDefaultShell()) + ")" : "";
            options = { "default": "Use system default" + current_system_default };
        }
        else {
            options = { "default": "Use default" };
        }
        for (const shell_path in PlatformShells[platform_id]) {
            // @ts-ignore // TODO: Get rid of these two ts-ignores.
            const shell_name = PlatformShells[platform_id][shell_path];
            // @ts-ignore
            options[shell_path] = shell_name;
        }
        new obsidian.Setting(container_element)
            .setName(platform_name + (is_global_settings ? " default shell" : " shell"))
            .setDesc((is_global_settings ? "Can be overridden by each shell command. " : "") + ("win32" === platform_id ? "Powershell is recommended over cmd.exe, because this plugin does not support escaping variables in CMD." : ""))
            .addDropdown(dropdown => dropdown
            .addOptions(options)
            .setValue(shells[platform_id] ?? "default")
            .onChange(((_platform_id) => {
            return async (value) => {
                if ("default" === value) {
                    // When using default shell, the value should be unset.
                    delete shells[_platform_id];
                }
                else {
                    // Normal case: assign the shell value.
                    shells[_platform_id] = value;
                }
                await plugin.saveSettings();
            };
        })(platform_id)));
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * Makes a textarea grow and shrink based on the content height, and applies CSS styles on it to make it look more like an <input> element (not so much padding).
 */
function decorateMultilineField(plugin, textareaComponent, extraOnChange) {
    const textareaElement = textareaComponent.inputEl;
    textareaElement.addClass("SC-multiline");
    const updateTextareaHeight = () => {
        // Resize the shell command textarea to match the amount of lines in it.
        const content = textareaElement.value;
        const placeholder = textareaElement.placeholder;
        const newlines_pattern = /\r\n|\r|\n/;
        const count_lines_in_shell_command = content.split(newlines_pattern).length;
        const count_lines_in_shell_command_placeholder = placeholder.split(newlines_pattern).length;
        let count_lines_final = Math.max(count_lines_in_shell_command, count_lines_in_shell_command_placeholder);
        if (plugin.settings.max_visible_lines_in_shell_command_fields) {
            // Limit the height so that the field will not take up too much space.
            count_lines_final = Math.min(plugin.settings.max_visible_lines_in_shell_command_fields, count_lines_final);
        }
        textareaElement.rows = count_lines_final;
    };
    updateTextareaHeight(); // Set a correct initial height.
    textareaComponent.onChange(() => {
        updateTextareaHeight(); // Update the height every time the field's value changes.
        if (extraOnChange) {
            extraOnChange(textareaElement.value);
        }
    });
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function CreateShellCommandFieldCore(plugin, container_element, setting_icon_and_name, shell_command, shell, t_shell_command, show_autocomplete_menu, extra_on_change, shell_command_placeholder = "Enter your command") {
    async function on_change(shell_command) {
        // Update preview
        setting_group.preview_setting.descEl.innerHTML = ""; // Remove previous content.
        createMultilineTextElement("span", // TODO: Maybe cleaner would be not to create a <span>, but to insert the content directly into descEl.
        await getShellCommandPreview(plugin, shell_command, shell, t_shell_command, null /* No event is available during preview. */), setting_group.preview_setting.descEl);
        // Let the caller extend this onChange, to preform saving the settings:
        extra_on_change(shell_command);
    }
    const setting_group = {
        name_setting: new obsidian.Setting(container_element)
            .setClass("SC-name-setting")
            .then((name_setting) => {
            name_setting.nameEl.innerHTML = setting_icon_and_name;
        }),
        shell_command_setting: new obsidian.Setting(container_element)
            .addTextArea(textareaComponent => {
            textareaComponent
                .setPlaceholder(shell_command_placeholder)
                .setValue(shell_command);
            decorateMultilineField(plugin, textareaComponent, on_change);
        })
            .setClass("SC-shell-command-setting"),
        preview_setting: new obsidian.Setting(container_element)
            .setClass("SC-preview-setting")
            .then(async (setting) => {
            setting.descEl.innerHTML = ""; // Remove previous content. Not actually needed here because it's empty already, but do it just in case.
            createMultilineTextElement("span", // TODO: Maybe cleaner would be not to create a <span>, but to insert the content directly into descEl.
            await getShellCommandPreview(plugin, shell_command, shell, t_shell_command, null /* No event is available during preview. */), setting.descEl);
        }),
    };
    // Autocomplete menu
    if (show_autocomplete_menu) {
        createAutocomplete(plugin, setting_group.shell_command_setting.settingEl.find("textarea"), on_change);
    }
    return setting_group;
}
/**
 *
 * @param plugin
 * @param shell_command
 * @param shell
 * @param t_shell_command
 * @param sc_event
 * @public Exported because createShellCommandField uses this.
 */
async function getShellCommandPreview(plugin, shell_command, shell, t_shell_command, sc_event) {
    const parsing_result = await parseVariables(plugin, shell_command, shell, t_shell_command, sc_event);
    if (!parsing_result.succeeded) {
        // Variable parsing failed.
        if (parsing_result.error_messages.length > 0) {
            // Return all error messages, each in its own line. (Usually there's just one message).
            return parsing_result.error_messages.join(os.EOL); // Newlines are converted to <br>'s by the consumers of this function.
        }
        else {
            // If there are no error messages, then errors are silently ignored by user's variable configuration.
            // The preview can then show the original, unparsed shell command.
            return shell_command;
        }
    }
    // Variable parsing succeeded
    return parsing_result.parsed_content;
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function createPlatformSpecificShellCommandField(plugin, container_element, t_shell_command, platform_id, show_autocomplete_menu) {
    const platform_name = PlatformNames[platform_id];
    const setting_group = CreateShellCommandFieldCore(plugin, container_element, "Shell command on " + platform_name, t_shell_command.getPlatformSpecificShellCommands()[platform_id] ?? "", t_shell_command.getShell(), t_shell_command, show_autocomplete_menu, async (shell_command) => {
        if (shell_command.length) {
            // shell_command is not empty, so it's a normal command.
            t_shell_command.getPlatformSpecificShellCommands()[platform_id] = shell_command;
        }
        else {
            // shell_command is empty, so the default command should be used.
            delete t_shell_command.getPlatformSpecificShellCommands()[platform_id];
        }
        await plugin.saveSettings();
    }, t_shell_command.getDefaultShellCommand());
    setting_group.name_setting.setDesc("If empty, the default shell command will be used on " + platform_name + ".");
    return setting_group;
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
function createTabs(container_element, tabs) {
    const tab_header = container_element.createEl("div", { attr: { class: "SC-tab-header" } });
    const tab_content_containers = {};
    const tab_buttons = {};
    const tab_structure = {
        header: tab_header,
        active_tab_id: Object.keys(tabs)[0],
        buttons: tab_buttons,
        contentContainers: tab_content_containers,
    };
    let first_button;
    for (const tab_id in tabs) {
        const tab = tabs[tab_id];
        // Create button
        const button = tab_header.createEl("button", {
            attr: {
                class: "SC-tab-header-button",
                activateTab: "SC-tab-" + tab_id,
            },
        });
        button.onclick = function (event) {
            const tab_button = this; // Use 'this' instead of event.target because this way we'll always get a button element, not an element inside the  button (i.e. an icon).
            // Hide all tab contents and get the max dimensions
            let max_width = 0;
            let max_height = 0;
            const tab_header = tab_button.parentElement;
            if (null === tab_header) {
                throw new Error("Tab header is missing. Did not get a parent from tab button.");
            }
            const container_element = tab_header.parentElement;
            if (null === container_element) {
                throw new Error("Container element is missing. Did not get a parent from tab header.");
            }
            const tab_contents = container_element.findAll("div.SC-tab-content"); // Do not get all tab contents that exist, because there might be multiple tab systems open at the same time.
            const is_main_settings_modal = container_element.hasClass("vertical-tab-content");
            for (const index in tab_contents) {
                const tab_content = tab_contents[index];
                // Get the maximum tab dimensions so that all tabs can have the same dimensions.
                // But don't do it if this is the main settings modal
                if (!is_main_settings_modal) {
                    tab_content.addClass("SC-tab-active"); // Need to make the tab visible temporarily in order to get the dimensions.
                    if (tab_content.offsetHeight > max_height) {
                        max_height = tab_content.offsetHeight;
                    }
                    if (tab_content.offsetWidth > max_width) {
                        max_width = tab_content.offsetWidth;
                    }
                }
                // Finally hide the tab
                tab_content.removeClass("SC-tab-active");
            }
            // Remove active status from all buttons
            const adjacent_tab_buttons = tab_header.findAll(".SC-tab-header-button"); // Do not get all tab buttons that exist, because there might be multiple tab systems open at the same time.
            for (const index in adjacent_tab_buttons) {
                const tab_button = adjacent_tab_buttons[index];
                tab_button.removeClass("SC-tab-active");
            }
            // Activate the clicked tab
            tab_button.addClass("SC-tab-active");
            const activateTabAttribute = tab_button.attributes.getNamedItem("activateTab");
            if (null === activateTabAttribute) {
                throw new Error("Tab button has no 'activateTab' HTML attribute! Murr!");
            }
            const activate_tab_id = activateTabAttribute.value;
            const tab_content = document.getElementById(activate_tab_id);
            if (null === tab_content) {
                throw new Error("No tab content was found with activate_tab_id '" + activate_tab_id + "'! Hmph!");
            }
            tab_content.addClass("SC-tab-active");
            // Mark the clicked tab as active in TabStructure (just to report which tab is currently active)
            tab_structure.active_tab_id = activate_tab_id.replace(/^SC-tab-/, ""); // Remove "SC-tab" prefix.
            // Focus an element (if a focusable element is present)
            tab_content.find(".SC-focus-element-on-tab-opening")?.focus(); // ? = If not found, do nothing.
            // Apply the max dimensions to this tab
            // But don't do it if this is the main settings modal
            if (!is_main_settings_modal) {
                tab_content.style.width = max_width + "px";
                tab_content.style.height = max_height + "px";
            }
            // Do nothing else (I don't know if this is needed or not)
            event.preventDefault();
        };
        obsidian.setIcon(button, tab.icon);
        button.insertAdjacentText("beforeend", " " + tab.title);
        tab_buttons[tab_id] = button;
        // Create content container
        tab_content_containers[tab_id] = container_element.createEl("div", { attr: { class: "SC-tab-content", id: "SC-tab-" + tab_id } });
        // Generate content
        tab.content_generator(tab_content_containers[tab_id]);
        // Memorize the first tab's button
        if (undefined === first_button) {
            first_button = button;
        }
    }
    // Activate the first tab
    if (undefined !== first_button) {
        first_button.click();
    }
    // Return the TabStructure
    return tab_structure;
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * TODO: Rename to ShellCommandSettingsModal
 */
class ExtraOptionsModal extends SC_Modal {
    constructor(plugin, shell_command_id, setting_tab) {
        super(plugin);
        this.shell_command_id = shell_command_id;
        this.t_shell_command = plugin.getTShellCommands()[shell_command_id];
        this.name_setting = setting_tab.setting_groups[shell_command_id].name_setting;
        this.setting_tab = setting_tab;
    }
    onOpen() {
        super.onOpen();
        this.modalEl.createEl("h2", { text: this.t_shell_command.getDefaultShellCommand() }); // TODO: Use this.setTitle() instead.
        // Tabs
        this.tab_structure = createTabs(this.modalEl, {
            "extra-options-general": {
                title: "General",
                icon: "gear",
                content_generator: (container_element) => {
                    this.tabGeneral(container_element);
                },
            },
            "extra-options-preactions": {
                title: "Preactions",
                icon: "note-glyph",
                content_generator: (container_element) => {
                    this.tabPreactions(container_element);
                },
            },
            "extra-options-output": {
                title: "Output",
                icon: "lines-of-text",
                content_generator: (container_element) => {
                    this.tabOutput(container_element);
                },
            },
            "extra-options-environments": {
                title: "Environments",
                icon: "stacked-levels",
                content_generator: (container_element) => {
                    this.tabEnvironments(container_element);
                },
            },
            "extra-options-events": {
                title: "Events",
                icon: "dice",
                content_generator: (container_element) => {
                    this.tabEvents(container_element);
                },
            },
            "extra-options-variables": {
                title: "Variables",
                icon: "code-glyph",
                content_generator: (container_element) => {
                    this.tabVariables(container_element);
                },
            },
        });
        // Hotkeys for moving to next/previous shell command
        const switch_to_t_shell_command = (t_shell_command) => {
            const new_modal = new ExtraOptionsModal(this.plugin, t_shell_command.getId(), this.setting_tab);
            this.close(); // Needs to be closed before the new one is opened, otherwise the new one's tab content won't be shown.
            new_modal.open();
            new_modal.activateTab(this.tab_structure.active_tab_id);
        };
        this.scope.register(["Mod"], "ArrowUp", () => {
            const previousTShellCommand = this.t_shell_command.previousTShellCommand();
            if (previousTShellCommand) {
                switch_to_t_shell_command(previousTShellCommand);
            }
        });
        this.scope.register(["Mod"], "ArrowDown", () => {
            const nextTShellCommand = this.t_shell_command.nextTShellCommand();
            if (nextTShellCommand) {
                switch_to_t_shell_command(nextTShellCommand);
            }
        });
        new obsidian.Setting(this.modalEl)
            .setDesc("Tip! Hit " + CmdOrCtrl() + " + up/down to switch to previous/next shell command.");
    }
    tabGeneral(container_element) {
        // Alias field
        const alias_container = container_element.createDiv({ attr: { class: "SC-setting-group" } });
        new obsidian.Setting(alias_container)
            .setName("Alias");
        const on_alias_change = async (value) => {
            // Change the actual alias value
            this.t_shell_command.getConfiguration().alias = value;
            // Update Obsidian command palette
            this.t_shell_command.renameObsidianCommand(this.t_shell_command.getShellCommand(), this.t_shell_command.getAlias());
            // UpdateShell commands settings panel
            this.name_setting.nameEl.innerHTML = generateShellCommandFieldIconAndName(this.t_shell_command);
            // Save
            await this.plugin.saveSettings();
        };
        const alias_setting = new obsidian.Setting(alias_container)
            .addText(text => text
            .setValue(this.t_shell_command.getAlias())
            .onChange(on_alias_change))
            .setClass("SC-no-description");
        const alias_input_element = alias_setting.controlEl.find("input");
        alias_input_element.addClass("SC-focus-element-on-tab-opening"); // Focus without a need to click the field.
        if (this.plugin.settings.show_autocomplete_menu) {
            // Show autocomplete menu (= a list of available variables).
            createAutocomplete(this.plugin, alias_input_element, on_alias_change);
        }
        alias_container.createEl("p", { text: "If not empty, the alias will be displayed in the command palette instead of the actual command. An alias is never executed as a command." });
        alias_container.createEl("p", { text: "You can also use the same {{}} style variables in aliases that are used in shell commands. When variables are used in aliases, they do not affect the command execution in any way, but it's a nice way to reveal what values your command will use, even when an alias hides most of the other technical details. Starting a variable with {{! will prevent escaping special characters in command palette." });
        // Icon field
        const current_icon = this.t_shell_command.getConfiguration().icon;
        const icon_setting = new obsidian.Setting(container_element)
            .setDesc("If defined, the icon will be shown in file menu, folder menu, and editor menu in front of the alias text. It's also shown in the settings. It makes it easier to distinguish different shell commands visually from each other.")
            .addDropdown(dropdown => dropdown
            .addOption("no-icon", "No icon") // Need to use a non-empty string like "no-icon", because if 'value' would be "" then it becomes the same as 'display' from some reason, i.e. "No icon".
            .then((dropdown) => {
            // Iterate all available icons.
            for (const icon_id of ICON_LIST_SORTED_UNIQUE) {
                // Create an option for the icon.
                dropdown.addOption(icon_id, icon_id);
            }
            dropdown.setValue(current_icon ?? ""); // "" == the 'No icon' option.
        })
            .onChange(async (new_icon) => {
            if ("no-icon" === new_icon) {
                // Disable icon
                this.t_shell_command.getConfiguration().icon = null;
                // Remove the icon from the modal
                icon_setting.nameEl.innerHTML = "Icon";
            }
            else {
                // Set or change the icon
                this.t_shell_command.getConfiguration().icon = new_icon;
                // Update the icon in the modal
                icon_setting.nameEl.innerHTML = "Icon " + getIconHTML(new_icon);
            }
            // Update (or remove) the icon in the main settings panel
            this.name_setting.nameEl.innerHTML = generateShellCommandFieldIconAndName(this.t_shell_command);
            // Save settings
            await this.plugin.saveSettings();
        }));
        icon_setting.nameEl.innerHTML = "Icon " + (current_icon ? getIconHTML(current_icon) : "");
        // Confirm execution field
        new obsidian.Setting(container_element)
            .setName("Ask confirmation before execution")
            .addToggle(toggle => toggle
            .setValue(this.t_shell_command.getConfirmExecution())
            .onChange(async (value) => {
            this.t_shell_command.getConfiguration().confirm_execution = value;
            const icon_container = this.name_setting.nameEl.find("span.shell-commands-confirm-execution-icon-container");
            if (this.t_shell_command.getConfirmExecution()) {
                // Show icon
                icon_container.removeClass("SC-hide");
            }
            else {
                // Hide icon
                icon_container.addClass("SC-hide");
            }
            await this.plugin.saveSettings();
        }));
        // Stdin field
        new obsidian.Setting(container_element)
            .setName("Pass variables to standard input (stdin) (experimental)")
            .setDesc("Used to pass long texts as input to the shell command. There is a limit to command line length, and e.g. {{note_content}} might provide a value too long to be used as an argument, so it works better when passed to stdin. Also, programs that ask multiple values interactively, can be fed with values using stdin. If there are multiple values that need to be inputted, put them on separate lines. Many shell programs interpret newlines as separators between different values.")
            .addExtraButton(extraButtonComponent => extraButtonComponent
            .setIcon("help")
            .setTooltip("Documentation: Pass variables to stdin")
            .onClick(() => gotoURL(DocumentationStdinContentLink)));
        const stdinSettingContainer = container_element.createDiv({ attr: { class: "SC-setting-group" } });
        const onStdinChange = async (newStdinContent) => {
            if ("" === newStdinContent) {
                // Set to null
                this.t_shell_command.getConfiguration().input_contents.stdin = null;
            }
            else {
                // Set value
                this.t_shell_command.getConfiguration().input_contents.stdin = newStdinContent;
            }
            await this.plugin.saveSettings();
        };
        new obsidian.Setting(stdinSettingContainer)
            .setDesc("Can contain {{variables}} and/or static text.")
            .addTextArea(textareaComponent => {
            textareaComponent
                .setValue(this.t_shell_command.getInputChannels().stdin ?? "");
            decorateMultilineField(this.plugin, textareaComponent, onStdinChange);
            if (this.plugin.settings.show_autocomplete_menu) {
                // Show autocomplete menu (= a list of available variables).
                createAutocomplete(this.plugin, textareaComponent.inputEl, onStdinChange);
            }
        });
        // Shell command id
        new obsidian.Setting(container_element)
            .setDesc(`Shell command id: ${this.shell_command_id}`)
            .addExtraButton(button => button
            .setIcon("documents")
            .setTooltip(`Copy ${this.shell_command_id} to the clipboard.`)
            .onClick(() => {
            copyToClipboard(this.shell_command_id);
            this.plugin.newNotification(`${this.shell_command_id} was copied to the clipboard.`);
        }));
        if (this.t_shell_command.canAddToCommandPalette()) {
            // Only show Obsidian command palette id if the shell command is available in the command palette.
            const obsidian_command_id = this.t_shell_command.getObsidianCommand().id;
            new obsidian.Setting(container_element)
                .setDesc(`Obsidian command palette id: ${obsidian_command_id}`)
                .addExtraButton(button => button
                .setIcon("documents")
                .setTooltip(`Copy ${obsidian_command_id} to the clipboard.`)
                .onClick(() => {
                copyToClipboard(obsidian_command_id);
                this.plugin.newNotification(`${obsidian_command_id} was copied to the clipboard.`);
            }))
                .settingEl.addClass("SC-no-top-border") // No horizontal ruler between the two id elements.
            ;
        }
    }
    tabPreactions(container_element) {
        container_element.createEl("p", { text: "Preactions are performed before the actual shell command gets executed, to do certain preparations for the shell command." });
        const preactions_configuration = this.t_shell_command.getConfiguration().preactions;
        // Load config values
        let preaction_prompt_configuration = null;
        for (const preaction_configuration of preactions_configuration) {
            switch (preaction_configuration.type) {
                case "prompt":
                    preaction_prompt_configuration = preaction_configuration;
                    break;
                default:
                    throw new Error("Unrecognised preaction type: " + preaction_configuration.type);
            }
        }
        // Preaction: Prompt
        const prompt_options = {};
        this.plugin.getPrompts().forEach((prompt) => {
            prompt_options[prompt.getID()] = prompt.getTitle();
        });
        let old_selected_prompt_option = (preaction_prompt_configuration?.enabled) ? preaction_prompt_configuration.prompt_id : "no-prompt";
        new obsidian.Setting(container_element)
            .setName("Prompt")
            .setDesc("Prompts are used to ask values from the user right before shell command execution. The values can be accessed in the shell command via custom variables. You can manage all prompts in the plugin's main settings view, under the 'Preactions' tab.")
            .addDropdown(dropdown => dropdown
            .addOption("no-prompt", "No prompt")
            .addOptions(prompt_options)
            .addOption("new", "Create a new prompt")
            .setValue(old_selected_prompt_option)
            .onChange(async (new_prompt_id) => {
            // Create a PreactionPromptConfiguration if it does not exist.
            if (!preaction_prompt_configuration) {
                preaction_prompt_configuration = getDefaultPreaction_Prompt_Configuration();
                preactions_configuration.push(preaction_prompt_configuration);
                this.t_shell_command.resetPreactions();
            }
            // Interpret the selection
            switch (new_prompt_id) {
                case "new": {
                    // Create a new Prompt.
                    const model = getModel(PromptModel.name);
                    const new_prompt = model.newInstance(this.plugin.settings);
                    this.plugin.saveSettings().then(() => {
                        const modal = new PromptSettingsModal(this.plugin, new_prompt, undefined, "Create prompt", async () => {
                            // Prompt is created.
                            dropdown.addOption(new_prompt.getID(), new_prompt.getTitle());
                            dropdown.setValue(new_prompt.getID());
                            preaction_prompt_configuration.enabled = true; // 'as Preaction_Prompt_Configuration' tells TypeScript that the variable is not null.
                            preaction_prompt_configuration.prompt_id = new_prompt.getID();
                            await this.plugin.saveSettings();
                            old_selected_prompt_option = dropdown.getValue();
                        }, async () => {
                            // Prompt creation was cancelled.
                            dropdown.setValue(old_selected_prompt_option); // Reset the dropdown selection.
                            model.deleteInstance(new_prompt);
                            await this.plugin.saveSettings();
                        });
                        modal.open();
                    });
                    break;
                }
                case "no-prompt": {
                    // Disable the prompt.
                    preaction_prompt_configuration.enabled = false;
                    this.t_shell_command.resetPreactions();
                    await this.plugin.saveSettings();
                    old_selected_prompt_option = dropdown.getValue();
                    break;
                }
                default: {
                    // Use an existing prompt.
                    preaction_prompt_configuration.enabled = true;
                    preaction_prompt_configuration.prompt_id = new_prompt_id;
                    await this.plugin.saveSettings();
                    old_selected_prompt_option = dropdown.getValue();
                    break;
                }
            }
        }));
    }
    tabOutput(container_element) {
        // Output channeling
        const stdout_channel_setting = this.newOutputChannelSetting(container_element, "Output channel for stdout", "stdout");
        this.newOutputChannelSetting(container_element, "Output channel for stderr", "stderr", "If both stdout and stderr use the same channel, stderr will be combined to same message with stdout.");
        // Output wrappers
        this.newOutputWrapperSetting(container_element, "Output wrapper for stdout", "stdout", "Output wrappers can be used to surround output with predefined text, e.g. to put output into a code block. Note: If 'Output mode' is 'Realtime', wrappers will probably appear multiple times in output!");
        this.newOutputWrapperSetting(container_element, "Output wrapper for stderr", "stderr");
        // Output handling mode
        new obsidian.Setting(container_element)
            .setName("Output handling mode")
            .setDesc("Set to 'Realtime' if your shell command runs for a long time AND you want output handling to start as soon as any outputted content is available. Output channels might be used multiple times during a single process. 'Wait until finished' postpones output handling until all output is received, and handles it as a single bunch. If uncertain, use the traditional 'Wait until finished'.")
            .addDropdown(dropdown => dropdown
            .addOptions({
            "buffered": "Wait until finished",
            "realtime": "Realtime (experimental)",
        })
            .setValue(this.t_shell_command.getConfiguration().output_handling_mode)
            .onChange(async (newMode) => {
            this.t_shell_command.getConfiguration().output_handling_mode = newMode;
            await this.plugin.saveSettings();
        }))
            // Documentation link
            .addExtraButton(icon => icon
            .setIcon("help")
            .onClick(() => gotoURL(DocumentationOutputHandlingModeLink))
            .setTooltip("Documentation: Output handling mode"));
        // Order of output channels
        new obsidian.Setting(container_element)
            .setName("Order of stdout/stderr output")
            .setDesc("When output contains both errors and normal output, which one should be presented first? (Only matters if 'Output handling' is 'Wait until finished').")
            .addDropdown(dropdown => dropdown
            .addOptions({
            "stdout-first": "Stdout first, then stderr.",
            "stderr-first": "Stderr first, then stdout.",
        })
            .setValue(this.t_shell_command.getOutputChannelOrder())
            .onChange(async (value) => {
            this.t_shell_command.getConfiguration().output_channel_order = value;
            await this.plugin.saveSettings();
        }));
        // Focus on the stdout channel dropdown field
        stdout_channel_setting.controlEl.find("select").addClass("SC-focus-element-on-tab-opening");
        // Ignore errors field
        new obsidian.Setting(container_element)
            .setName("Ignore error codes")
            .setDesc("A comma separated list of numbers. If executing a shell command fails with one of these exit codes, no error message will be displayed, and the above stderr channel will be ignored. Stdout channel will still be used for stdout. Error codes must be integers and greater than or equal to 0. Anything else will be removed. Note: If 'Output handling' is 'Realtime', no exit code based ignoring can be done, as an error code is only received when a shell command process finishes.")
            .addText(text => text
            .setValue(this.t_shell_command.getIgnoreErrorCodes().join(","))
            .onChange(async (value) => {
            // Parse the string of comma separated numbers
            const ignore_error_codes = [];
            const raw_error_codes = value.split(",");
            for (const i in raw_error_codes) {
                const raw_error_code = raw_error_codes[i];
                const error_code_candidate = parseInt(raw_error_code.trim()); // E.g. an empty string converts to NaN (= Not a Number).
                // Ensure that the error code is not NaN, 0 or a negative number.
                if (!isNaN(error_code_candidate) && error_code_candidate >= 0) {
                    // The candidate is legit.
                    ignore_error_codes.push(error_code_candidate);
                }
            }
            // Save the validated error numbers
            this.t_shell_command.getConfiguration().ignore_error_codes = ignore_error_codes;
            await this.plugin.saveSettings();
            // Update icon
            const icon_container = this.name_setting.nameEl.find("span.shell-commands-ignored-error-codes-icon-container");
            if (this.t_shell_command.getIgnoreErrorCodes().length) {
                // Show icon
                icon_container.setAttr("aria-label", generateIgnoredErrorCodesIconTitle(this.t_shell_command.getIgnoreErrorCodes()));
                icon_container.removeClass("SC-hide");
            }
            else {
                // Hide icon
                icon_container.addClass("SC-hide");
            }
        }));
    }
    tabEnvironments(container_element) {
        // Platform specific shell commands
        let platform_id;
        let is_first = true;
        for (platform_id in PlatformNames) {
            const setting_group = createPlatformSpecificShellCommandField(this.plugin, container_element, this.t_shell_command, platform_id, this.plugin.settings.show_autocomplete_menu);
            if (is_first) {
                // Focus on the first OS specific shell command field
                setting_group.shell_command_setting.controlEl.find("textarea").addClass("SC-focus-element-on-tab-opening");
                is_first = false;
            }
        }
        // Platform specific shell selection
        createShellSelectionField(this.plugin, container_element, this.t_shell_command.getShells(), false);
    }
    tabEvents(container_element) {
        // Command palette
        const command_palette_availability_setting = new obsidian.Setting(container_element)
            .setName("Availability in Obsidian's command palette")
            .addDropdown(dropdown => dropdown
            .addOptions(CommandPaletteOptions)
            .setValue(this.t_shell_command.getConfiguration().command_palette_availability)
            .onChange(async (value) => {
            // Store value
            this.t_shell_command.getConfiguration().command_palette_availability = value;
            // Update command palette
            if (this.t_shell_command.canAddToCommandPalette()) {
                // Register to command palette
                this.t_shell_command.registerToCommandPalette();
            }
            else {
                // Unregister from command palette
                this.t_shell_command.unregisterFromCommandPalette();
            }
            // Save
            await this.plugin.saveSettings();
        }));
        // Focus on the command palette availability field
        command_palette_availability_setting.controlEl.find("select").addClass("SC-focus-element-on-tab-opening");
        // Events
        new obsidian.Setting(container_element)
            .setName("Execute this shell command automatically when:")
            .setHeading() // Make the name bold
        ;
        getSC_Events(this.plugin).forEach((sc_event) => {
            const is_event_enabled = this.t_shell_command.isSC_EventEnabled(sc_event.static().getCode());
            const setting = new obsidian.Setting(container_element)
                .setName(sc_event.static().getTitle())
                .addToggle(toggle => toggle
                .setValue(is_event_enabled)
                .onChange(async (enable) => {
                if (enable) {
                    // Enable the event
                    this.t_shell_command.enableSC_Event(sc_event);
                    extra_settings_container.style.display = "block"; // Show extra settings
                }
                else {
                    // Disable the event
                    this.t_shell_command.disableSC_Event(sc_event);
                    extra_settings_container.style.display = "none"; // Hide extra settings
                }
                // Save
                await this.plugin.saveSettings();
            }))
                // Documentation icon
                .addExtraButton(icon => icon
                .setIcon("help")
                .onClick(() => gotoURL(sc_event.static().getDocumentationLink()))
                .setTooltip("Documentation: " + sc_event.static().getTitle() + " event"));
            // Mention additional variables (if any)
            if (sc_event.createSummaryOfEventVariables(setting.descEl)) {
                setting.descEl.insertAdjacentText("afterbegin", "Additional variables: ");
            }
            // Extra settings
            const extra_settings_container = container_element.createDiv();
            extra_settings_container.style.display = is_event_enabled ? "block" : "none";
            sc_event.createExtraSettingsFields(extra_settings_container, this.t_shell_command);
        });
    }
    tabVariables(containerElement) {
        // Default values for variables
        new obsidian.Setting(containerElement)
            .setName("Default values for variables")
            .setDesc("Certain variables can be inaccessible during certain situations, e.g. {{file_name}} is not available when no file pane is focused. You can define default values that will be used when a variable is otherwise unavailable.")
            .setHeading();
        createVariableDefaultValueFields(this.plugin, containerElement, this.t_shell_command);
    }
    activateTab(tab_id) {
        if (undefined === this.tab_structure.buttons[tab_id]) {
            throw Error("Invalid tab id: " + tab_id);
        }
        this.tab_structure.buttons[tab_id].click();
    }
    newOutputChannelSetting(container_element, title, output_stream_name, description = "") {
        const output_channel_options = getOutputChannelsOptionList(output_stream_name);
        return new obsidian.Setting(container_element)
            .setName(title)
            .setDesc(description)
            .addDropdown(dropdown => dropdown
            .addOptions(output_channel_options)
            .setValue(this.t_shell_command.getOutputChannels()[output_stream_name])
            .onChange(async (value) => {
            this.t_shell_command.getConfiguration().output_channels[output_stream_name] = value;
            await this.plugin.saveSettings();
        }));
    }
    newOutputWrapperSetting(container_element, title, output_stream_name, description = "") {
        const output_wrapper_options = {};
        this.plugin.getOutputWrappers().forEach((output_wrapper) => {
            output_wrapper_options[output_wrapper.getID()] = output_wrapper.getTitle();
        });
        const output_wrappers = this.t_shell_command.getConfiguration().output_wrappers;
        let old_selected_output_wrapper_option = output_wrappers[output_stream_name] ?? "no-output-wrapper";
        return new obsidian.Setting(container_element)
            .setName(title)
            .setDesc(description)
            .addDropdown(dropdown_component => dropdown_component
            .addOption("no-output-wrapper", "No " + output_stream_name + " wrapper")
            .addOptions(output_wrapper_options)
            .addOption("new", "Create a new output wrapper")
            .setValue(old_selected_output_wrapper_option)
            .onChange(async (output_wrapper_id) => {
            switch (output_wrapper_id) {
                case "new": {
                    // Create a new OutputWrapper.
                    const output_wrapper_model = getModel(OutputWrapperModel.name);
                    const new_output_wrapper = output_wrapper_model.newInstance(this.plugin.settings);
                    this.plugin.saveSettings().then(() => {
                        const modal = new OutputWrapperSettingsModal(this.plugin, new_output_wrapper, undefined, "Create output wrapper", async () => {
                            // Output wrapper is created.
                            dropdown_component.addOption(new_output_wrapper.getID(), new_output_wrapper.getTitle());
                            dropdown_component.setValue(new_output_wrapper.getID());
                            output_wrappers[output_stream_name] = new_output_wrapper.getID();
                            await this.plugin.saveSettings();
                            old_selected_output_wrapper_option = dropdown_component.getValue();
                        }, async () => {
                            // Prompt creation was cancelled.
                            dropdown_component.setValue(old_selected_output_wrapper_option); // Reset the dropdown selection.
                            output_wrapper_model.deleteInstance(new_output_wrapper);
                            await this.plugin.saveSettings();
                        });
                        modal.open();
                    });
                    break;
                }
                case "no-output-wrapper": {
                    // Disable output wrapper.
                    output_wrappers[output_stream_name] = null;
                    await this.plugin.saveSettings();
                    break;
                }
                default: {
                    // Use an existing output wrapper.
                    output_wrappers[output_stream_name] = output_wrapper_id;
                    await this.plugin.saveSettings();
                    break;
                }
            }
        }));
    }
    approve() {
        // No need to perform any action, just close the modal.
        this.close();
    }
}
ExtraOptionsModal.GENERAL_OPTIONS_SUMMARY = "Alias, Icon, Confirmation, Stdin";
ExtraOptionsModal.PREACTIONS_OPTIONS_SUMMARY = "Preactions: Prompt for asking values from user";
ExtraOptionsModal.OUTPUT_OPTIONS_SUMMARY = "Stdout/stderr handling, Ignore errors";
ExtraOptionsModal.ENVIRONMENTS_OPTIONS_SUMMARY = "Shell selection, Operating system specific shell commands";
ExtraOptionsModal.EVENTS_SUMMARY = "Events";
ExtraOptionsModal.VARIABLES_SUMMARY = "Default values for variables";

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 * TODO: Rename to DeleteShellCommandModal
 */
class DeleteModal extends SC_Modal {
    constructor(plugin, shell_command_id, setting_group, shell_command_element) {
        super(plugin);
        this.shell_command_id = shell_command_id;
        this.t_shell_command = plugin.getTShellCommands()[shell_command_id];
        this.setting_group = setting_group;
        this.shell_command_element = shell_command_element;
    }
    onOpen() {
        super.onOpen();
        this.modalEl.createEl("h2", { text: "Delete: " + this.t_shell_command.getShellCommand() }); // TODO: Use this.setTitle() instead.
        if (this.t_shell_command.getAlias()) {
            this.modalEl.createEl("p", { text: "Alias: " + this.t_shell_command.getAlias() });
        }
        this.modalEl.createEl("p", { text: "Are you sure you want to delete this shell command?" });
        const delete_button = this.modalEl.createEl("button", { text: "Yes, delete" });
        delete_button.onclick = async () => this.approve();
    }
    async approve() {
        // Unregister possible events in order to prevent them becoming ghosts that just keep executing even after removing the configuration.
        this.t_shell_command.unregisterSC_Events();
        // Remove the command
        debugLog("Command " + this.shell_command_id + " gonna be removed.");
        this.t_shell_command.unregisterFromCommandPalette(); // Remove from the command palette.
        delete this.plugin.getTShellCommands()[this.shell_command_id]; // Remove the TShellCommand object.
        // Remove from the plugin's settings.
        const shellCommandIndex = this.plugin.getShellCommandConfigurationIndex(this.shell_command_id);
        // Index probably always exists, but check just in case. Will make TypeScript compiler happy. :)
        if (undefined == shellCommandIndex) {
            throw new Error("Shell command deletion failed. Did not get shell command index in settings container.");
        }
        this.plugin.settings.shell_commands.splice(shellCommandIndex, 1);
        // Remove the setting fields
        this.shell_command_element.remove();
        await this.plugin.saveSettings();
        debugLog("Command removed.");
        this.close();
    }
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
/**
 *
 * @param plugin
 * @param container_element
 * @param setting_tab
 * @param shell_command_id Either a string formatted integer ("0", "1" etc) or "new" if it's a field for a command that does not exist yet.
 * @param show_autocomplete_menu
 */
function createShellCommandField(plugin, container_element, setting_tab, shell_command_id, show_autocomplete_menu) {
    const is_new = "new" === shell_command_id;
    let t_shell_command;
    if (is_new) {
        // Create an empty command
        t_shell_command = plugin.newTShellCommand();
        shell_command_id = t_shell_command.getId(); // Replace "new" with a real id.
    }
    else {
        // Use an old shell command
        t_shell_command = plugin.getTShellCommands()[shell_command_id];
    }
    debugLog("Create command field for command #" + shell_command_id + (is_new ? " (NEW)" : ""));
    let shell_command;
    if (is_new) {
        shell_command = "";
    }
    else {
        shell_command = t_shell_command.getDefaultShellCommand();
    }
    // Wrap all shell command setting elements in a single div.
    const shell_command_element = container_element.createDiv();
    shell_command_element.addClass("SC-id-" + shell_command_id);
    const setting_group = CreateShellCommandFieldCore(plugin, shell_command_element, generateShellCommandFieldIconAndName(t_shell_command), shell_command, t_shell_command.getShell(), t_shell_command, show_autocomplete_menu, async (shell_command) => {
        if (is_new) {
            debugLog("Creating new command " + shell_command_id + ": " + shell_command);
        }
        else {
            debugLog("Command " + shell_command_id + " gonna change to: " + shell_command);
        }
        // Do this in both cases, when creating a new command and when changing an old one:
        t_shell_command.getConfiguration().platform_specific_commands.default = shell_command;
        if (is_new) {
            // Create a new command
            // plugin.registerShellCommand(t_shell_command); // I don't think this is needed to be done anymore
            debugLog("Command created.");
        }
        else {
            // Change an old command
            t_shell_command.renameObsidianCommand(t_shell_command.getShellCommand(), t_shell_command.getAlias()); // Change the command's name in Obsidian's command palette and in hotkey settings.
            debugLog("Command changed.");
        }
        await plugin.saveSettings();
    });
    setting_tab.setting_groups[shell_command_id] = setting_group;
    // Primary icon buttons
    setting_group.name_setting
        .addExtraButton(button => button
        .setTooltip("Normal click: Execute now. " + CmdOrCtrl() + " + click: Execute and ask what to do with output.")
        .setIcon("run-command")
        .extraSettingsEl.addEventListener("click", async (event) => {
        const ctrl_clicked = event.ctrlKey;
        // Execute the shell command now (for trying it out in the settings)
        const parsing_process = t_shell_command.createParsingProcess(null); // No SC_Event is available when executing shell commands manually.
        if (await parsing_process.process()) {
            const executor = new ShellCommandExecutor(plugin, t_shell_command, null); // No SC_Event is available when manually executing the shell command.
            await executor.doPreactionsAndExecuteShellCommand(parsing_process, ctrl_clicked ? "modal" : undefined // If ctrl/cmd is pressed, override output channels with 'Ask after execution' modal. Otherwise, use undefined to indicate that the shell command's normal output channels should be used.
            );
        }
        else {
            parsing_process.displayErrorMessages();
        }
    }))
        .addExtraButton(button => button
        .setTooltip(ExtraOptionsModal.GENERAL_OPTIONS_SUMMARY)
        .onClick(async () => {
        // Open an extra options modal: General tab
        const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);
        modal.open();
        modal.activateTab("extra-options-general");
    }))
        .addExtraButton(button => button
        .setTooltip(ExtraOptionsModal.PREACTIONS_OPTIONS_SUMMARY)
        .setIcon("note-glyph")
        .onClick(async () => {
        // Open an extra options modal: Preactions tab
        const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);
        modal.open();
        modal.activateTab("extra-options-preactions");
    }))
        .addExtraButton(button => button
        .setTooltip(ExtraOptionsModal.OUTPUT_OPTIONS_SUMMARY)
        .setIcon("lines-of-text")
        .onClick(async () => {
        // Open an extra options modal: Output tab
        const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);
        modal.open();
        modal.activateTab("extra-options-output");
    }))
        .addExtraButton(button => button
        .setTooltip(ExtraOptionsModal.ENVIRONMENTS_OPTIONS_SUMMARY)
        .setIcon("stacked-levels")
        .onClick(async () => {
        // Open an extra options modal: Environments tab
        const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);
        modal.open();
        modal.activateTab("extra-options-environments");
    }))
        .addExtraButton(button => button
        .setTooltip(ExtraOptionsModal.EVENTS_SUMMARY)
        .setIcon("dice")
        .onClick(async () => {
        // Open an extra options modal: Events tab
        const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);
        modal.open();
        modal.activateTab("extra-options-events");
    }))
        .addExtraButton(button => button
        .setTooltip(ExtraOptionsModal.VARIABLES_SUMMARY)
        .setIcon("code-glyph")
        .onClick(async () => {
        // Open an extra options modal: Variables tab
        const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);
        modal.open();
        modal.activateTab("extra-options-variables");
    }))
        .addExtraButton(button => button
        .setTooltip("Delete this shell command")
        .setIcon("trash")
        .onClick(async () => {
        // Open a delete modal
        const modal = new DeleteModal(plugin, shell_command_id, setting_group, shell_command_element);
        modal.open();
    }));
    // Informational icons (= non-clickable)
    const icon_container = setting_group.name_setting.nameEl.createEl("span", { attr: { class: "SC-main-icon-container" } });
    // "Ask confirmation" icon.
    const confirm_execution_icon_container = icon_container.createEl("span", { attr: { "aria-label": "Asks confirmation before execution.", class: "shell-commands-confirm-execution-icon-container" } });
    obsidian.setIcon(confirm_execution_icon_container, "languages");
    if (!t_shell_command.getConfirmExecution()) {
        // Do not display the icon for commands that do not use confirmation.
        confirm_execution_icon_container.addClass("SC-hide");
    }
    // "Ignored error codes" icon
    const ignored_error_codes_icon_container = icon_container.createEl("span", { attr: { "aria-label": generateIgnoredErrorCodesIconTitle(t_shell_command.getIgnoreErrorCodes()), class: "shell-commands-ignored-error-codes-icon-container" } });
    obsidian.setIcon(ignored_error_codes_icon_container, "strikethrough-glyph");
    if (!t_shell_command.getIgnoreErrorCodes().length) {
        // Do not display the icon for commands that do not ignore any errors.
        ignored_error_codes_icon_container.addClass("SC-hide");
    }
    // Secondary icon buttons
    setting_group.preview_setting.addExtraButton(button => button
        .setIcon("link")
        .setTooltip("Copy this shell command's Obsidian URI to the clipboard. Visiting the URI executes the shell command. " + CmdOrCtrl() + " + click: Copy a markdown link.")
        // onClick() handler - use a custom one instead of ExtraButtonComponent.onClick(), because Obsidian API (at least v. 0.14.8) does not support detecting CTRL press. https://forum.obsidian.md/t/fr-settings-pass-mouseevent-to-extrabuttoncomponent-onclick/37177
        .extraSettingsEl.addEventListener("click", (event) => {
        const ctrl_clicked = event.ctrlKey;
        const execution_uri = t_shell_command.getExecutionURI();
        let result;
        if (ctrl_clicked) {
            // A full link is wanted.
            result = `[${escapeMarkdownLinkCharacters(t_shell_command.getAlias())}](${escapeMarkdownLinkCharacters(execution_uri)})`;
        }
        else {
            // Only the URI is wanted.
            result = execution_uri;
        }
        copyToClipboard(result);
        plugin.newNotification("Copied to clipboard: " + os.EOL + result);
    }));
    if (t_shell_command.canHaveHotkeys()) {
        setting_group.preview_setting.addExtraButton(button => button
            .setIcon("any-key")
            .setTooltip("Go to hotkey settings.")
            .onClick(() => {
            // The most important parts of this closure function are copied 2022-04-27 from https://github.com/pjeby/hotkey-helper/blob/c8a032e4c52bd9ce08cb909cec15d1ed9d0a3439/src/plugin.js#L436-L442 (also from other lines of the same file).
            // @ts-ignore This is private API access. Not good, but then again the feature is not crucial - if it breaks, it won't interrupt anything important.
            plugin.app.setting?.openTabById("hotkeys");
            // @ts-ignore
            const hotkeys_settings_tab = plugin.app.setting.settingTabs.filter(tab => tab.id === "hotkeys").shift();
            if (hotkeys_settings_tab && hotkeys_settings_tab.searchInputEl && hotkeys_settings_tab.updateHotkeyVisibility) {
                debugLog("Hotkeys: Filtering by shell command " + t_shell_command.getObsidianCommand().name);
                hotkeys_settings_tab.searchInputEl.value = t_shell_command.getObsidianCommand().name;
                hotkeys_settings_tab.updateHotkeyVisibility();
            }
            else {
                debugLog("Hotkeys: Cannot do filtering due to API changes.");
            }
        }));
    }
    // Add hotkey information
    if (!is_new && t_shell_command.canHaveHotkeys()) {
        const hotkeys = getHotkeysForShellCommand(plugin, shell_command_id);
        if (hotkeys) {
            let hotkeys_joined = "";
            hotkeys.forEach((hotkey) => {
                if (hotkeys_joined) {
                    hotkeys_joined += "<br>";
                }
                hotkeys_joined += HotkeyToString(hotkey);
            });
            const hotkey_div = setting_group.preview_setting.controlEl.createEl("div", { attr: { class: "setting-item-description SC-hotkey-info" } });
            // Comment out the icon because it would look like a clickable button (as there are other clickable icons in the settings).
            // setIcon(hotkey_div, "any-key", 22); // Hotkey icon
            hotkey_div.insertAdjacentHTML("beforeend", " " + hotkeys_joined);
        }
    }
    debugLog("Created.");
}
/**
 * @param t_shell_command
 * @public Exported because ShellCommandExtraOptionsModal uses this too.
 */
function generateShellCommandFieldIconAndName(t_shell_command) {
    const icon_html = t_shell_command.getIconHTML() + " ";
    if (t_shell_command.getAlias()) {
        return icon_html + t_shell_command.getAlias();
    }
    return icon_html + "Shell command without alias";
}
/**
 * @param ignored_error_codes
 * @public Exported because ShellCommandExtraOptionsModal uses this too.
 */
function generateIgnoredErrorCodesIconTitle(ignored_error_codes) {
    const plural = ignored_error_codes.length !== 1 ? "s" : "";
    return "Ignored error" + plural + ": " + ignored_error_codes.join(",");
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_MainSettingsTab extends obsidian.PluginSettingTab {
    constructor(app, plugin) {
        super(app, plugin);
        this.setting_groups = {};
        this.last_position = {
            scroll_position: 0,
            tab_name: "main-shell-commands",
        };
        this.plugin = plugin;
    }
    display() {
        const { containerEl } = this;
        containerEl.empty();
        this.tab_structure = createTabs(containerEl, {
            "main-shell-commands": {
                title: "Shell commands",
                icon: "run-command",
                content_generator: (container_element) => {
                    this.tabShellCommands(container_element);
                },
            },
            "main-environments": {
                title: "Environments",
                icon: "stacked-levels",
                content_generator: (container_element) => {
                    this.tabEnvironments(container_element);
                },
            },
            "main-preactions": {
                title: "Preactions",
                icon: "note-glyph",
                content_generator: (container_element) => {
                    this.tabPreactions(container_element);
                },
            },
            "main-output": {
                title: "Output",
                icon: "lines-of-text",
                content_generator: (container_element) => {
                    this.tabOutput(container_element);
                },
            },
            "main-events": {
                title: "Events",
                icon: "dice",
                content_generator: (container_element) => {
                    this.tabEvents(container_element);
                },
            },
            "main-variables": {
                title: "Variables",
                icon: "code-glyph",
                content_generator: (container_element) => {
                    this.tabVariables(container_element);
                },
            },
        });
        // Documentation link & GitHub links
        containerEl.createEl("p").insertAdjacentHTML("beforeend", "<a href=\"" + DocumentationMainLink + "\">Documentation</a> - " +
            "<a href=\"" + GitHubLink + "\">SC on GitHub</a> - " +
            "<a href=\"" + ChangelogLink + "\">SC version: " + this.plugin.getPluginVersion() + "</a>");
        // Copyright notice
        const copyright_paragraph = containerEl.createEl("p");
        copyright_paragraph.addClass("SC-small-font");
        copyright_paragraph.insertAdjacentHTML("beforeend", `
            <em>Shell commands</em> plugin Copyright &copy; 2021 - 2023 Jarkko Linnanvirta. This program comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome to redistribute it under certain conditions. See more information in the license: <a href="${LicenseLink}">GNU GPL-3.0</a>.
        `);
        // KEEP THIS AFTER CREATING ALL ELEMENTS:
        this.rememberLastPosition(containerEl);
    }
    tabShellCommands(container_element) {
        // Show a search field
        this.createSearchField(container_element);
        // A <div> element for all command input fields. New command fields can be created at the bottom of this element.
        const command_fields_container = container_element.createEl("div");
        // Fields for modifying existing commands
        let shell_commands_exist = false;
        for (const command_id in this.plugin.getTShellCommands()) {
            createShellCommandField(this.plugin, command_fields_container, this, command_id, this.plugin.settings.show_autocomplete_menu);
            shell_commands_exist = true;
        }
        // 'No shell commands yet' paragraph.
        const no_shell_commands_paragraph = container_element.createEl("p", { text: "No shell commands yet, click the 'New shell command' button below." });
        if (shell_commands_exist) {
            // Shell commands exist, so do not show the "No shell commands yet" text.
            no_shell_commands_paragraph.hide();
        }
        // "New command" button
        new obsidian.Setting(container_element)
            .addButton(button => button
            .setButtonText("New shell command")
            .onClick(async () => {
            createShellCommandField(this.plugin, command_fields_container, this, "new", this.plugin.settings.show_autocomplete_menu);
            no_shell_commands_paragraph.hide();
            debugLog("New empty command created.");
        }));
    }
    createSearchField(container_element) {
        const search_container = container_element.createDiv();
        const search_title = "Search shell commands";
        const search_setting = new obsidian.Setting(search_container)
            .setName(search_title)
            .setDesc("Looks up shell commands' aliases, commands, ids and icons.")
            .addSearch(search_component => search_component
            .onChange((search_term) => {
            let count_matches = 0;
            for (const shell_command_id in this.plugin.getTShellCommands()) {
                let matched = false;
                // Check if a search term was defined.
                if ("" == search_term) {
                    // Show all shell commands.
                    matched = true;
                }
                else {
                    // A search term is defined.
                    // Define fields where to look for the search term
                    const t_shell_command = this.plugin.getTShellCommands()[shell_command_id];
                    const search_targets = [
                        t_shell_command.getId(),
                        t_shell_command.getConfiguration().alias,
                    ];
                    search_targets.push(...Object.values(t_shell_command.getPlatformSpecificShellCommands()));
                    // Only include icon in the search if it's defined.
                    const icon = t_shell_command.getConfiguration().icon;
                    if (icon) {
                        search_targets.push(icon);
                    }
                    // Check if it's a match
                    search_targets.forEach((search_target) => {
                        if (search_target.toLocaleLowerCase().contains(search_term.toLocaleLowerCase())) {
                            matched = true;
                            debugLog("Search " + search_term + " MATCHED " + search_target);
                        }
                    });
                }
                // Show or hide the shell command.
                const shell_command_element = document.querySelector("div.SC-id-" + shell_command_id);
                if (!shell_command_element) {
                    throw new Error("Shell command setting element does not exist with selector div.SC-id-" + shell_command_id);
                }
                if (matched) {
                    shell_command_element.removeClass("SC-hide");
                    count_matches++;
                }
                else {
                    shell_command_element.addClass("SC-hide");
                }
            }
            // Display match count
            if ("" == search_term) {
                // Don't show match count.
                search_setting.setName(search_title);
            }
            else {
                // Show match count.
                switch (count_matches) {
                    case 0: {
                        search_setting.setName("No matches");
                        break;
                    }
                    case 1: {
                        search_setting.setName("1 match");
                        break;
                    }
                    default: {
                        search_setting.setName(count_matches + " matches");
                        break;
                    }
                }
            }
        }).then((search_component) => {
            // Focus on the search field.
            search_component.inputEl.addClass("SC-focus-element-on-tab-opening");
        }));
    }
    tabEvents(container_element) {
        // A general description about events
        container_element.createEl("p", { text: "Events introduce a way to execute shell commands automatically in certain situations, e.g. when Obsidian starts. They are set up for each shell command separately, but this tab contains general options for them." });
        // Enable/disable all events
        new obsidian.Setting(container_element)
            .setName("Enable events")
            .setDesc("This is a quick way to immediately turn off all events, if you want.")
            .addToggle(toggle => toggle
            .setValue(this.plugin.settings.enable_events)
            .onChange(async (enable_events) => {
            // The toggle was clicked.
            this.plugin.settings.enable_events = enable_events;
            if (enable_events) {
                // Register events.
                this.plugin.registerSC_Events(true);
            }
            else {
                // Unregister events.
                this.plugin.unregisterSC_Events();
            }
            await this.plugin.saveSettings();
        }));
        // A list of current enable events
        container_element.createEl("p", { text: "The following gives just a quick glance over which events are enabled on which shell commands. To enable/disable events for a shell command, go to the particular shell command's settings via the 'Shell commands' tab. The list is only updated when you reopen the whole settings panel." });
        let found_enabled_event = false;
        getSC_Events(this.plugin).forEach((sc_event) => {
            const event_enabled_t_shell_commands = sc_event.getTShellCommands();
            // Has the event been enabled for any shell commands?
            if (event_enabled_t_shell_commands.length) {
                // Yes, it's enabled.
                // Show a list of shell commands
                const paragraph_element = container_element.createEl("p", { text: sc_event.static().getTitle() });
                const list_element = paragraph_element.createEl("ul");
                event_enabled_t_shell_commands.forEach((t_shell_command) => {
                    list_element.createEl("li", { text: t_shell_command.getAliasOrShellCommand() });
                });
                found_enabled_event = true;
            }
        });
        if (!found_enabled_event) {
            container_element.createEl("p", { text: "No events are enabled for any shell commands." });
        }
    }
    tabVariables(container_element) {
        // "Preview variables in command palette" field
        new obsidian.Setting(container_element)
            .setName("Preview variables in command palette and menus")
            .setDesc("If on, variable names are substituted with their realtime values when you view your commands in the command palette and right click context menus (if used). A nice way to ensure your commands will use correct values.")
            .addToggle(checkbox => checkbox
            .setValue(this.plugin.settings.preview_variables_in_command_palette)
            .onChange(async (value) => {
            debugLog("Changing preview_variables_in_command_palette to " + value);
            this.plugin.settings.preview_variables_in_command_palette = value;
            await this.plugin.saveSettings();
        }));
        // "Show autocomplete menu" field
        new obsidian.Setting(container_element)
            .setName("Show autocomplete menu")
            .setDesc("If on, a dropdown menu shows up when you begin writing {{variable}} names, showing matching variables and their instructions. Also allows defining custom suggestions in autocomplete.yaml file - see the documentation.")
            .addToggle(checkbox => checkbox
            .setValue(this.plugin.settings.show_autocomplete_menu)
            .onChange(async (value) => {
            debugLog("Changing show_autocomplete_menu to " + value);
            this.plugin.settings.show_autocomplete_menu = value;
            this.display(); // Re-render the whole settings view to apply the change.
            await this.plugin.saveSettings();
        }))
            .addExtraButton(extra_button => extra_button
            .setIcon("help")
            .setTooltip("Documentation: Autocomplete")
            .onClick(() => {
            gotoURL(DocumentationAutocompleteLink);
        }));
        // Custom variables
        new obsidian.Setting(container_element)
            .setName("Custom variables")
            .setHeading() // Make the "Variables" text bold.
            .addExtraButton(extra_button => extra_button
            .setIcon("pane-layout")
            .setTooltip("Open a pane that displays all custom variables and their values.")
            .onClick(() => {
            this.plugin.createCustomVariableView();
        }))
            .addExtraButton(extra_button => extra_button
            .setIcon("help")
            .setTooltip("Documentation: Custom variables")
            .onClick(() => {
            gotoURL(DocumentationCustomVariablesLink);
        }));
        // Settings for each CustomVariable
        const custom_variable_model = getModel(CustomVariableModel.name);
        const custom_variable_container = container_element.createDiv();
        this.plugin.getCustomVariableInstances().forEach((custom_variable_instance) => {
            custom_variable_model.createSettingFields(custom_variable_instance, custom_variable_container);
        });
        createNewModelInstanceButton(this.plugin, CustomVariableModel.name, container_element, custom_variable_container, this.plugin.settings).then();
        // Built-in variable instructions
        new obsidian.Setting(container_element)
            .setName("Built-in variables")
            .setHeading() // Make the "Variables" text bold.
            .addExtraButton(extra_button => extra_button
            .setIcon("help")
            .setTooltip("Documentation: Built-in variables")
            .onClick(() => {
            gotoURL(DocumentationBuiltInVariablesIndexLink);
        }));
        for (const variable of this.plugin.getVariables()) {
            if (!(variable instanceof CustomVariable)) {
                const variableSettingGroupElement = container_element.createDiv();
                variableSettingGroupElement.addClass("SC-setting-group");
                // Variable name and documentation link
                const variableHeadingSetting = new obsidian.Setting(variableSettingGroupElement) // Use container_element instead of variableSettingGroup.
                    .setHeading()
                    .addExtraButton(extraButton => extraButton
                    .setIcon("help")
                    .setTooltip("Documentation: " + variable.getFullName() + " variable")
                    .onClick(() => gotoURL(variable.getDocumentationLink())));
                variableHeadingSetting.nameEl.insertAdjacentHTML("afterbegin", variable.getHelpName());
                // Variable description
                const variableDescriptionSetting = new obsidian.Setting(variableSettingGroupElement)
                    .setClass("SC-full-description") // Without this, description would be shrunk to 50% of space. This setting does not have control elements, so 100% width is ok.
                ;
                variableDescriptionSetting.descEl.insertAdjacentHTML("afterbegin", variable.help_text);
                const availability_text = variable.getAvailabilityText();
                if (availability_text) {
                    variableDescriptionSetting.descEl.insertAdjacentHTML("beforeend", "<br>" + availability_text);
                }
                // Variable default value
                const defaultValueSettingTitle = "Default value for " + variable.getFullName();
                if (variable.isAlwaysAvailable()) {
                    new obsidian.Setting(variableSettingGroupElement)
                        .setName(defaultValueSettingTitle)
                        .setDesc(variable.getFullName() + " is always available, so it cannot have a default value.");
                }
                else {
                    createVariableDefaultValueField(this.plugin, variableSettingGroupElement, defaultValueSettingTitle, variable);
                }
            }
        }
        container_element.createEl("p", { text: "When you type variables into commands, a preview text appears under the command field to show how the command will look like when it gets executed with variables substituted with their real values." });
        container_element.createEl("p", { text: "Special characters in variable values are tried to be escaped (except if you use CMD as the shell in Windows). This is to improve security so that a variable won't accidentally cause bad things to happen. If you want to use a raw, unescaped value, add an exclamation mark before the variable's name, e.g. {{!title}}, but be careful, it's dangerous!" });
        container_element.createEl("p", { text: "There is no way to prevent variable parsing. If you need {{ }} characters in your command, they won't be parsed as variables as long as they do not contain any of the variable names listed above. If you need to pass e.g. {{title}} literally to your command, there is no way to do it atm, please create a discussion in GitHub." });
        container_element.createEl("p", { text: "All variables that access the current file, may cause the command preview to fail if you had no file panel active when you opened the settings window - e.g. you had focus on graph view instead of a note = no file is currently active. But this does not break anything else than the preview." });
    }
    tabEnvironments(container_element) {
        // "Working directory" field
        new obsidian.Setting(container_element)
            .setName("Working directory")
            .setDesc("A directory where your commands will be run. If empty, defaults to your vault's location. Can be relative (= a folder in the vault) or absolute (= complete from filesystem root).")
            .addText(text => text
            .setPlaceholder(getVaultAbsolutePath(this.app))
            .setValue(this.plugin.settings.working_directory)
            .onChange(async (value) => {
            debugLog("Changing working_directory to " + value);
            this.plugin.settings.working_directory = value;
            await this.plugin.saveSettings();
        }));
        // Platforms' default shells
        createShellSelectionField(this.plugin, container_element, this.plugin.settings.default_shells, true);
        // PATH environment variable fields
        createPATHAugmentationFields(this.plugin, container_element, this.plugin.settings.environment_variable_path_augmentations);
    }
    tabPreactions(container_element) {
        // Prompts
        const prompt_model = getModel(PromptModel.name);
        new obsidian.Setting(container_element)
            .setName("Prompts")
            .setHeading() // Make the "Prompts" text to appear as a heading.
        ;
        const prompts_container_element = container_element.createDiv();
        this.plugin.getPrompts().forEach((prompt) => {
            prompt_model.createSettingFields(prompt, prompts_container_element);
        });
        // 'New prompt' button
        const new_prompt_button_promise = createNewModelInstanceButton(this.plugin, PromptModel.name, container_element, prompts_container_element, this.plugin.settings);
        new_prompt_button_promise.then((result) => {
            prompt_model.openSettingsModal(result.instance, result.main_setting); // Open the prompt settings modal, as the user will probably want to configure it now anyway.
        });
    }
    tabOutput(container_element) {
        // Output wrappers
        const output_wrapper_model = getModel(OutputWrapperModel.name);
        new obsidian.Setting(container_element)
            .setName("Output wrappers")
            .setHeading() // Make the "Output wrappers" text to appear as a heading.
            .addExtraButton(extra_button => extra_button
            .setIcon("help")
            .setTooltip("Documentation: Output wrappers")
            .onClick(() => gotoURL(DocumentationOutputWrappersLink)));
        const output_wrappers_container_element = container_element.createDiv();
        this.plugin.getOutputWrappers().forEach((output_wrapper) => {
            output_wrapper_model.createSettingFields(output_wrapper, output_wrappers_container_element);
        });
        // 'New output wrapper' button
        const new_output_wrapper_button_promise = createNewModelInstanceButton(this.plugin, OutputWrapperModel.name, container_element, output_wrappers_container_element, this.plugin.settings);
        new_output_wrapper_button_promise.then((result) => {
            output_wrapper_model.openSettingsModal(result.instance, result.main_setting); // Open the output wrapper settings modal, as the user will probably want to configure it now anyway.
        });
        // "Error message duration" field
        this.createNotificationDurationField(container_element, "Error message duration", "Concerns messages about failed shell commands.", "error_message_duration");
        // "Notification message duration" field
        this.createNotificationDurationField(container_element, "Notification message duration", "Concerns informational, non-fatal messages, e.g. output directed to 'Notification balloon'.", "notification_message_duration");
        // "Show a notification when executing shell commands" field
        new obsidian.Setting(container_element)
            .setName("Show a notification when executing shell commands")
            .addDropdown(dropdown_component => dropdown_component
            .addOptions({
            "disabled": "Do not show",
            "quick": "Show for " + this.plugin.settings.notification_message_duration + " seconds",
            "permanent": "Show until the process is finished",
            "if-long": "Show only if executing takes long",
        })
            .setValue(this.plugin.settings.execution_notification_mode)
            .onChange(async (new_execution_notification_mode) => {
            // Save the change.
            this.plugin.settings.execution_notification_mode = new_execution_notification_mode;
            await this.plugin.saveSettings();
        }));
        // "Output channel 'Clipboard' displays a notification message, too" field
        new obsidian.Setting(container_element)
            .setName("Output channel 'Clipboard' displays a notification message, too")
            .setDesc("If a shell command's output is directed to the clipboard, also show the output in a popup box on the top right corner. This helps to notice what was inserted into clipboard.")
            .addToggle(checkbox => checkbox
            .setValue(this.plugin.settings.output_channel_clipboard_also_outputs_to_notification)
            .onChange(async (value) => {
            this.plugin.settings.output_channel_clipboard_also_outputs_to_notification = value;
            await this.plugin.saveSettings();
        }));
    }
    createNotificationDurationField(container_element, title, description, setting_name) {
        new obsidian.Setting(container_element)
            .setName(title)
            .setDesc(description + " In seconds, between 1 and 180.")
            .addText(field => field
            .setValue(String(this.plugin.settings[setting_name]))
            .onChange(async (duration_string) => {
            const duration = parseInt(duration_string);
            if (duration >= 1 && duration <= 180) {
                debugLog("Change " + setting_name + " from " + this.plugin.settings[setting_name] + " to " + duration);
                this.plugin.settings[setting_name] = duration;
                await this.plugin.saveSettings();
                debugLog("Changed.");
            }
            // Don't show a notice if duration is not between 1 and 180, because this function is called every time a user types in this field, so the value might not be final.
        }));
    }
    rememberLastPosition(container_element) {
        const last_position = this.last_position;
        // Go to last position now
        this.tab_structure.buttons[last_position.tab_name].click();
        window.setTimeout(() => {
            container_element.scrollTo({
                top: this.last_position.scroll_position,
                behavior: "auto",
            });
        }, 0); // 'timeout' can be 0 ms, no need to wait any longer.
        // Listen to changes
        container_element.addEventListener("scroll", (event) => {
            this.last_position.scroll_position = container_element.scrollTop;
        });
        for (const tab_name in this.tab_structure.buttons) {
            const button = this.tab_structure.buttons[tab_name];
            button.onClickEvent((event) => {
                last_position.tab_name = tab_name;
            });
        }
    }
}

/**
 * Copied 2021-10-29 from https://gist.github.com/TheDistantSea/8021359
 * Modifications:
 *  - Made compatible with TypeScript by adding type definitions.
 *  - Changed var to let.
 *
 * Compares two software version numbers (e.g. "1.7.1" or "1.2b").
 *
 * This function was born in http://stackoverflow.com/a/6832721.
 *
 * @param {string} v1 The first version to be compared.
 * @param {string} v2 The second version to be compared.
 * @param {object} [options] Optional flags that affect comparison behavior:
 * <ul>
 *     <li>
 *         <tt>lexicographical: true</tt> compares each part of the version strings lexicographically instead of
 *         naturally; this allows suffixes such as "b" or "dev" but will cause "1.10" to be considered smaller than
 *         "1.2".
 *     </li>
 *     <li>
 *         <tt>zeroExtend: true</tt> changes the result if one version string has less parts than the other. In
 *         this case the shorter string will be padded with "zero" parts instead of being considered smaller.
 *     </li>
 * </ul>
 * @returns {number|NaN}
 * <ul>
 *    <li>0 if the versions are equal</li>
 *    <li>a negative integer iff v1 < v2</li>
 *    <li>a positive integer iff v1 > v2</li>
 *    <li>NaN if either version string is in the wrong format</li>
 * </ul>
 *
 * @copyright by Jon Papaioannou (["john", "papaioannou"].join(".") + "@gmail.com")
 * @license This function is in the public domain. Do what you want with it, no strings attached.
 */
function versionCompare(v1, v2, options = {}) {
    let lexicographical = options && options.lexicographical, zeroExtend = options && options.zeroExtend, v1parts = v1.split('.'), v2parts = v2.split('.');
    function isValidPart(x) {
        return (lexicographical ? /^\d+[A-Za-z]*$/ : /^\d+$/).test(x);
    }
    if (!v1parts.every(isValidPart) || !v2parts.every(isValidPart)) {
        return NaN;
    }
    if (zeroExtend) {
        while (v1parts.length < v2parts.length)
            v1parts.push("0");
        while (v2parts.length < v1parts.length)
            v2parts.push("0");
    }
    if (!lexicographical) {
        v1parts = v1parts.map(Number);
        v2parts = v2parts.map(Number);
    }
    for (let i = 0; i < v1parts.length; ++i) {
        if (v2parts.length == i) {
            return 1;
        }
        if (v1parts[i] == v2parts[i]) {
            continue;
        }
        else if (v1parts[i] > v2parts[i]) {
            return 1;
        }
        else {
            return -1;
        }
    }
    if (v1parts.length != v2parts.length) {
        return -1;
    }
    return 0;
}

/*
 * 'Shell commands' plugin for Obsidian.
 * Copyright (C) 2021 - 2023 Jarkko Linnanvirta
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.0 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/
 */
class SC_Plugin extends obsidian.Plugin {
    constructor() {
        super(...arguments);
        this.obsidian_commands = {};
        this.t_shell_commands = {};
        /**
         * Holder for shell commands and aliases, whose variables are parsed before the actual execution during command
         * palette preview. This array gets emptied after every time a shell command is executed via the command palette.
         *
         * This is only used for command palette, not when executing a shell command from the settings panel, nor when
         * executing shell commands via SC_Events.
         *
         * @private
         */
        this.cached_parsing_processes = {};
        this.autocompleteMenus = [];
    }
    async onload() {
        debugLog('loading plugin');
        // Load settings
        if (!await this.loadSettings()) {
            // Loading the settings has failed due to an unsupported settings file version.
            // The plugin should not be used, and it has actually disabled itself, but the code execution needs to be
            // stopped manually.
            return;
        }
        // Define models
        introduceModels(this);
        // Run possible configuration migrations
        await RunMigrations(this);
        // Generate TShellCommand objects from configuration (only after configuration migrations are done)
        this.loadTShellCommands();
        // Load Prompts
        const prompt_model = getModel(PromptModel.name);
        this.prompts = prompt_model.loadInstances(this.settings);
        // Load CustomVariables (configuration instances)
        const custom_variable_model = getModel(CustomVariableModel.name);
        this.custom_variable_instances = custom_variable_model.loadInstances(this.settings);
        // Load variables (both built-in and custom ones). Do this AFTER loading configs for custom variables!
        this.variables = loadVariables(this);
        // Load output wrappers
        const output_wrapper_model = getModel(OutputWrapperModel.name);
        this.output_wrappers = output_wrapper_model.loadInstances(this.settings);
        // Make all defined shell commands to appear in the Obsidian command palette.
        const shell_commands = this.getTShellCommands();
        for (const shell_command_id in shell_commands) {
            const t_shell_command = shell_commands[shell_command_id];
            if (t_shell_command.canAddToCommandPalette()) {
                this.registerShellCommand(t_shell_command);
            }
        }
        // Perform event registrations, if enabled.
        if (this.settings.enable_events) {
            this.registerSC_Events(false);
        }
        // Load a custom autocomplete list if it exists.
        this.loadCustomAutocompleteList();
        // Create a SettingsTab.
        this.addSettingTab(new SC_MainSettingsTab(this.app, this));
        // Make it possible to create CustomVariableViews.
        this.registerView(CustomVariableView.ViewType, (leaf) => new CustomVariableView(this, leaf));
        // Debug reserved IDs
        debugLog("IDGenerator's reserved IDs:");
        debugLog(getIDGenerator().getReservedIDs());
        // Register an URI handler.
        this.registerURIHandler();
    }
    loadTShellCommands() {
        this.t_shell_commands = {}; // TODO: Consider changing this to either an array or a Map.
        const shell_command_configurations = this.getShellCommandConfigurations();
        for (const shell_command_configuration of shell_command_configurations) {
            this.t_shell_commands[shell_command_configuration.id] = new TShellCommand(this, shell_command_configuration);
        }
    }
    getTShellCommands() {
        return this.t_shell_commands;
    }
    getVariables() {
        return this.variables;
    }
    getPrompts() {
        return this.prompts;
    }
    getCustomVariableInstances() {
        return this.custom_variable_instances;
    }
    getShellCommandConfigurations() {
        return this.settings.shell_commands;
    }
    getOutputWrappers() {
        return this.output_wrappers;
    }
    /**
     * Tries to find an index at which a ShellCommandConfiguration object is located in this.settings.shell_commands.
     * Returns undefined, if it's not found.
     *
     * DO NOT EXPOSE THE INDEX OUTSIDE THE PLUGIN! It's not a stable reference to a shell command, because shell commands
     * can be reordered (well, at least in some future version of the plugin). Always use the ID as a stable, externally
     * safe reference!
     *
     * @param shell_command_id
     */
    getShellCommandConfigurationIndex(shell_command_id) {
        return this.settings.shell_commands.findIndex((shell_command_configuration) => {
            return shell_command_configuration.id == shell_command_id;
        });
    }
    /**
     * Returns an Obsidian URI that complies with the format obsidian://action/?vault=XYZ and that may contain possible
     * custom arguments at the end.
     *
     * Note that if 'action' is 'open' and a 'file' argument is present in 'uri_arguments', the URI will use the shorthand syntax described here: https://help.obsidian.md/Advanced+topics/Using+obsidian+URI#Shorthand+formats
     *
     * @param action
     * @param uri_arguments
     */
    getObsidianURI(action, uri_arguments = {}) {
        const encoded_vault_name = encodeURIComponent(this.app.vault.getName());
        let base_uri;
        // Check which kind of uri type should be used: shorthand or normal
        if ("open" === action && uri_arguments.file !== undefined) {
            // Use shorthand uri type for opening a file.
            const encoded_file = encodeURIComponent(uri_arguments.file);
            base_uri = `obsidian://vault/${encoded_vault_name}/${encoded_file}`;
            delete uri_arguments.file; // Prevent adding an extra '&file=' argument to the end of the URI.
        }
        else {
            // Use normal uri type for everything else.
            base_uri = `obsidian://${action}/?vault=${encoded_vault_name}`;
        }
        let concatenated_uri_arguments = "";
        for (const uri_argument_name in uri_arguments) {
            const uri_argument_value = encodeURIComponent(uri_arguments[uri_argument_name]);
            concatenated_uri_arguments += `&${uri_argument_name}=${uri_argument_value}`;
        }
        return base_uri + concatenated_uri_arguments;
    }
    /**
     * Creates a new shell command object and registers it to Obsidian's command palette, but does not save the modified
     * configuration to disk. To save the addition, call saveSettings().
     */
    newTShellCommand() {
        const shell_command_id = getIDGenerator().generateID();
        const shell_command_configuration = newShellCommandConfiguration(shell_command_id);
        this.settings.shell_commands.push(shell_command_configuration);
        const t_shell_command = new TShellCommand(this, shell_command_configuration);
        this.t_shell_commands[shell_command_id] = t_shell_command;
        if (t_shell_command.canAddToCommandPalette()) { // This is probably always true, because the default configuration enables adding to the command palette, but check just in case.
            this.registerShellCommand(t_shell_command);
        }
        return t_shell_command;
    }
    /**
     * TODO: Move to TShellCommand.registerToCommandPalette(), but split to multiple methods.
     *
     * @param t_shell_command
     */
    registerShellCommand(t_shell_command) {
        const shell_command_id = t_shell_command.getId();
        debugLog("Registering shell command #" + shell_command_id + "...");
        // Define a function for executing the shell command.
        const executor = async (parsing_process) => {
            if (!parsing_process) {
                parsing_process = t_shell_command.createParsingProcess(null); // No SC_Event is available when executing shell commands via the command palette / hotkeys.
                // Try to process variables that can be processed before performing preactions.
                await parsing_process.process();
            }
            if (parsing_process.getParsingResults().shell_command?.succeeded) { // .shell_command should always be present (even if parsing did not succeed), but if it's not, show errors in the else block.
                // The command was parsed correctly.
                const executor_instance = new ShellCommandExecutor(// Named 'executor_instance' because 'executor' is another constant.
                this, t_shell_command, null // No SC_Event is available when executing via command palette or hotkey.
                );
                await executor_instance.doPreactionsAndExecuteShellCommand(parsing_process);
            }
            else {
                // The command could not be parsed correctly.
                // Display error messages
                parsing_process.displayErrorMessages();
            }
        };
        // Register an Obsidian command
        const obsidian_command = {
            id: this.generateObsidianCommandId(shell_command_id),
            name: generateObsidianCommandName(this, t_shell_command.getShellCommand(), t_shell_command.getAlias()),
            // Use 'checkCallback' instead of normal 'callback' because we also want to get called when the command palette is opened.
            checkCallback: (is_opening_command_palette) => {
                if (is_opening_command_palette) {
                    // The user is currently opening the command palette.
                    // Check can the shell command be shown in command palette
                    if (!t_shell_command.canShowInCommandPalette()) {
                        // Cancel preview and deny showing in command palette.
                        debugLog("Shell command #" + t_shell_command.getId() + " won't be shown in command palette.");
                        return false;
                    }
                    // Do not execute the command yet, but parse variables for preview, if enabled in the settings.
                    debugLog("Getting command palette preview for shell command #" + t_shell_command.getId());
                    if (this.settings.preview_variables_in_command_palette) {
                        // Preparse variables
                        const parsing_process = t_shell_command.createParsingProcess(null); // No SC_Event is available when executing shell commands via the command palette / hotkeys.
                        parsing_process.process().then((parsing_succeeded) => {
                            if (parsing_succeeded) {
                                // Parsing succeeded
                                // Rename Obsidian command
                                const parsingResults = parsing_process.getParsingResults();
                                /** Don't confuse this name with ShellCommandParsingResult interface! The properties are very different. TODO: Rename ShellCommandParsingResult to something else. */
                                const shellCommandParsingResult = parsingResults["shell_command"]; // Use 'as' to denote that properties exist on this line and below.
                                const aliasParsingResult = parsingResults["alias"];
                                const parsedShellCommand = shellCommandParsingResult.parsed_content;
                                const parsedAlias = aliasParsingResult.parsed_content;
                                t_shell_command.renameObsidianCommand(parsedShellCommand, parsedAlias);
                                // Store the preparsed variables so that they will be used if this shell command gets executed.
                                this.cached_parsing_processes[t_shell_command.getId()] = parsing_process;
                            }
                            else {
                                // Parsing failed, so use unparsed t_shell_command.getShellCommand() and t_shell_command.getAlias().
                                t_shell_command.renameObsidianCommand(t_shell_command.getShellCommand(), t_shell_command.getAlias());
                                this.cached_parsing_processes[t_shell_command.getId()] = undefined;
                            }
                        });
                    }
                    else {
                        // Parsing is disabled, so use unparsed t_shell_command.getShellCommand() and t_shell_command.getAlias().
                        t_shell_command.renameObsidianCommand(t_shell_command.getShellCommand(), t_shell_command.getAlias());
                        this.cached_parsing_processes[t_shell_command.getId()] = undefined;
                    }
                    return true; // Tell Obsidian this command can be shown in command palette.
                }
                else {
                    // The user has instructed to execute the command.
                    executor(this.cached_parsing_processes[t_shell_command.getId()]).then(() => {
                        // Delete the whole array of preparsed commands. Even though we only used just one command from it, we need to notice that opening a command
                        // palette might generate multiple preparsed commands in the array, but as the user selects and executes only one command, all these temporary
                        // commands are now obsolete. Delete them just in case the user toggles the variable preview feature off in the settings, or executes commands via hotkeys. We do not want to
                        // execute obsolete commands accidentally.
                        // This deletion also needs to be done even if the executed command was not a preparsed command, because
                        // even when preparsing is turned on in the settings, some commands may fail to parse, and therefore they would not be in this array, but other
                        // commands might be.
                        this.cached_parsing_processes = {}; // Removes obsolete preparsed variables from all shell commands.
                        return; // When we are not in the command palette check phase, there's no need to return a value. Just have this 'return' statement because all other return points have a 'return' too.
                    });
                }
            }
        };
        this.addCommand(obsidian_command);
        this.obsidian_commands[shell_command_id] = obsidian_command; // Store the reference so that we can edit the command later in ShellCommandsSettingsTab if needed. TODO: Use tShellCommand instead.
        t_shell_command.setObsidianCommand(obsidian_command);
        debugLog("Registered.");
    }
    /**
     * Goes through all events and all shell commands, and for each shell command, registers all the events that the shell
     * command as enabled in its configuration. Does not modify the configurations.
     *
     * @param called_after_changing_settings Set to: true, if this happens after changing configuration; false, if this happens during loading the plugin.
     */
    registerSC_Events(called_after_changing_settings) {
        // Make sure that Obsidian is fully loaded before allowing any events to trigger.
        this.app.workspace.onLayoutReady(() => {
            // Even after Obsidian is fully loaded, wait a while in order to prevent SC_Event_onActiveLeafChanged triggering right after start-up.
            // At least on Obsidian 0.12.19 it's not enough to delay until onLayoutReady, need to wait a bit more in order to avoid the miss-triggering.
            window.setTimeout(() => {
                // Iterate all shell commands and register possible events.
                const shell_commands = this.getTShellCommands();
                for (const shell_command_id in shell_commands) {
                    const t_shell_command = shell_commands[shell_command_id];
                    t_shell_command.registerSC_Events(called_after_changing_settings);
                }
            }, 0); // 0 means to call the callback on "the next event cycle", according to window.setTimeout() documentation. It should be a long enough delay. But if SC_Event_onActiveLeafChanged still gets triggered during start-up, this value can be raised to for example 1000 (= one second).
        });
    }
    /**
     * Goes through all events and all shell commands, and makes sure all of them are unregistered, e.g. will not trigger
     * automatically. Does not modify the configurations.
     */
    unregisterSC_Events() {
        // Iterate all events
        getSC_Events(this).forEach((sc_event) => {
            // Iterate all shell commands
            const shell_commands = this.getTShellCommands();
            for (const shell_command_id in shell_commands) {
                const t_shell_command = shell_commands[shell_command_id];
                sc_event.unregister(t_shell_command);
            }
        });
    }
    /**
     * Defines an Obsidian protocol handler that allows receiving requests via obsidian://shell-commands URI.
     * @private
     */
    registerURIHandler() {
        this.registerObsidianProtocolHandler(SC_Plugin.SHELL_COMMANDS_URI_ACTION, async (parameters) => {
            const parameter_names = Object.getOwnPropertyNames(parameters);
            // Assign values to custom variables (also delete some unneeded entries from parameter_names)
            let custom_variable_assignments_failed = false;
            for (const parameter_index in parameter_names) {
                const parameter_name = parameter_names[parameter_index];
                // Check if the parameter name is a custom variable
                if (parameter_name.match(/^_/)) {
                    // This parameter defines a value for a custom variable
                    // Find the variable.
                    let found_custom_variable = false;
                    for (const variable of this.getVariables()) {
                        if (variable instanceof CustomVariable && variable.variable_name === parameter_name) {
                            // Found the correct variable.
                            found_custom_variable = true;
                            // Assign the given value to the custom variable.
                            await variable.setValue(parameters[parameter_name]);
                        }
                    }
                    if (!found_custom_variable) {
                        this.newError("Shell commands URI: A custom variable does not exist: " + parameter_name);
                        custom_variable_assignments_failed = true;
                    }
                }
            }
            if (!custom_variable_assignments_failed) {
                // Determine action
                if (undefined !== parameters.execute) {
                    // Execute a shell command.
                    const executable_shell_command_id = parameters.execute;
                    parameter_names.remove("execute"); // Mark the parameter as handled. Prevents showing an error message for an unrecognised parameter.
                    // Find the executable shell command
                    let found_t_shell_command = false;
                    const shell_commands = this.getTShellCommands();
                    for (const shell_command_id in shell_commands) {
                        const t_shell_command = shell_commands[shell_command_id];
                        if (t_shell_command.getId() === executable_shell_command_id) {
                            // This is the correct shell command.
                            found_t_shell_command = true;
                            // Execute it.
                            const executor = new ShellCommandExecutor(this, t_shell_command, null);
                            await executor.doPreactionsAndExecuteShellCommand();
                        }
                    }
                    if (!found_t_shell_command) {
                        this.newError("Shell commands URI: A shell command id does not exist: " + executable_shell_command_id);
                    }
                }
            }
            // Raise errors for any left-over parameters, if exists.
            for (const parameter_name of parameter_names) {
                switch (parameter_name) {
                    case "": // For some reason Obsidian 0.14.5 adds an empty-named parameter if there are no ?query=parameters present.
                    case "action": // Obsidian provides this always. Don't show an error message for this.
                    case "vault": // Obsidian handles this parameter automatically. Just make sure no error message is displayed when this is present.
                        // Do nothing
                        break;
                    default:
                        if (parameter_name.match(/^_/)) ;
                        else {
                            // Throw an error for everything else.
                            this.newError("Shell commands URI: Unrecognised parameter: " + parameter_name);
                        }
                }
            }
        });
    }
    generateObsidianCommandId(shell_command_id) {
        return "shell-command-" + shell_command_id;
    }
    onunload() {
        debugLog('Unloading Shell commands plugin.');
        // Close CustomVariableViews.
        this.app.workspace.detachLeavesOfType(CustomVariableView.ViewType);
        // Close autocomplete menus.
        for (const autocompleteMenu of this.autocompleteMenus) {
            autocompleteMenu?.destroy();
        }
    }
    /**
     *
     * @param current_settings_version
     * @private
     * @return True if the given settings version is supported by this plugin version, or an error message string if it's not supported.
     */
    isSettingsVersionSupported(current_settings_version) {
        if (current_settings_version === "prior-to-0.7.0") {
            // 0.x.y supports all old settings formats that do not define a version number. This support will be removed in 1.0.0.
            return true;
        }
        else {
            // Compare the version number
            /** Note that the plugin version may be different than what will be used in the version comparison. The plugin version will be displayed in possible error messages. */
            const plugin_version = this.getPluginVersion();
            const version_comparison = versionCompare(SC_Plugin.SettingsVersion, current_settings_version);
            if (version_comparison === 0) {
                // The versions are equal.
                // Supported.
                return true;
            }
            else if (version_comparison < 0) {
                // The compared version is newer than what the plugin can support.
                return "The settings file is saved by a newer version of this plugin, so this plugin does not support the structure of the settings file. Please upgrade this plugin to at least version " + current_settings_version + ". Now the plugin version is " + plugin_version;
            }
            else {
                // The compared version is older than the version that the plugin currently uses to write settings.
                // 0.x.y supports all old settings versions. In 1.0.0, some old settings formats might lose their support, but that's not yet certain.
                return true;
            }
        }
    }
    getPluginVersion() {
        return this.manifest.version;
    }
    async loadSettings() {
        // Try to read a settings file
        let all_settings;
        this.settings = await this.loadData(); // May have missing main settings fields, if the settings file is from an older version of SC. It will be migrated later.
        if (null === this.settings) {
            // The settings file does not exist.
            // Use default settings
            this.settings = getDefaultSettings(true);
            all_settings = this.settings;
        }
        else {
            // Succeeded to load a settings file.
            // In case the settings file does not have 'debug' or 'settings_version' fields, create them.
            all_settings = combineObjects(getDefaultSettings(false), this.settings); // This temporary settings object always has all fields defined (except sub fields, such as shell command specific fields, may still be missing, but they are not needed this early). This is used so that it's certain that the fields 'debug' and 'settings_version' exist.
        }
        // Update debug status - before this line debugging is always OFF!
        setDEBUG_ON(all_settings.debug);
        // Ensure that the loaded settings file is supported.
        const version_support = this.isSettingsVersionSupported(all_settings.settings_version);
        if (typeof version_support === "string") {
            // The settings version is not supported.
            new obsidian.Notice("SHELL COMMANDS PLUGIN HAS DISABLED ITSELF in order to prevent misinterpreting settings / corrupting the settings file!", 120 * 1000);
            new obsidian.Notice(version_support, 120 * 1000);
            await this.disablePlugin();
            return false; // The plugin should not be used.
        }
        return true; // Settings are loaded and the plugin can be used.
    }
    async saveSettings() {
        // Update settings version in case it's old.
        this.settings.settings_version = SC_Plugin.SettingsVersion;
        // Write settings
        await this.saveData(this.settings);
    }
    loadCustomAutocompleteList() {
        const custom_autocomplete_file_name = "autocomplete.yaml";
        const custom_autocomplete_file_path = path__namespace.join(getPluginAbsolutePath(this), custom_autocomplete_file_name);
        if (fs__namespace.existsSync(custom_autocomplete_file_path)) {
            debugLog("loadCustomAutocompleteList(): " + custom_autocomplete_file_name + " exists, will load it now.");
            const custom_autocomplete_content = fs__namespace.readFileSync(custom_autocomplete_file_path).toLocaleString();
            const result = addCustomAutocompleteItems(custom_autocomplete_content);
            if (true === result) {
                // OK
                debugLog("loadCustomAutocompleteList(): " + custom_autocomplete_file_name + " loaded.");
            }
            else {
                // An error has occurred.
                debugLog("loadCustomAutocompleteList(): " + result);
                this.newError("Shell commands: Unable to parse " + custom_autocomplete_file_name + ": " + result);
            }
        }
        else {
            debugLog("loadCustomAutocompleteList(): " + custom_autocomplete_file_name + " does not exists, so won't load it. This is perfectly ok.");
        }
    }
    /**
     * Puts the given Autocomplete menu into a list of menus that will be destroyed when the plugin unloads.
     * @param autocompleteMenu
     */
    registerAutocompleteMenu(autocompleteMenu) {
        this.autocompleteMenus.push(autocompleteMenu);
    }
    async disablePlugin() {
        // This unfortunately accesses a private API.
        // @ts-ignore
        await this.app.plugins.disablePlugin(this.manifest.id);
    }
    getPluginId() {
        return this.manifest.id;
    }
    getPluginName() {
        return this.manifest.name;
    }
    newError(message, timeout = this.getErrorMessageDurationMs()) {
        return new obsidian.Notice(message, timeout);
    }
    newErrors(messages) {
        messages.forEach((message) => {
            this.newError(message);
        });
    }
    /**
     *
     * @param message
     * @param timeout Custom timeout in milliseconds. If not set, the timeout will be fetched from user configurable settings. Use 0 if you want to disable the timeout, i.e. show the notification until it's explicitly hidden by clinking it, or via code.
     */
    newNotification(message, timeout = this.getNotificationMessageDurationMs()) {
        return new obsidian.Notice(message, timeout);
    }
    getNotificationMessageDurationMs() {
        return this.settings.notification_message_duration * 1000; // * 1000 = convert seconds to milliseconds.
    }
    getErrorMessageDurationMs() {
        return this.settings.error_message_duration * 1000; // * 1000 = convert seconds to milliseconds.
    }
    getDefaultShell() {
        const operating_system = getOperatingSystem();
        let shell_name = this.settings.default_shells[operating_system]; // Can also be undefined.
        if (undefined === shell_name) {
            shell_name = getUsersDefaultShell();
        }
        return shell_name;
    }
    createCustomVariableView() {
        const leaf = this.app.workspace.getRightLeaf(false);
        leaf.setViewState({
            type: CustomVariableView.ViewType,
            active: true,
        }).then();
        this.app.workspace.revealLeaf(leaf);
    }
    /**
     * Called when CustomVariable values are changed.
     */
    async updateCustomVariableViews() {
        for (const leaf of this.app.workspace.getLeavesOfType(CustomVariableView.ViewType)) {
            await leaf.view.updateContent();
        }
    }
    /**
     * Used by OutputChannel_StatusBar.
     * TODO: Make it possible to have multiple status bar elements. It should be a shell command level setting, where a shell command opts for either to use their own status bar element, or a common one.
     */
    getOutputStatusBarElement() {
        if (!this.statusBarElement) {
            this.statusBarElement = this.addStatusBarItem();
        }
        return this.statusBarElement;
    }
    /**
     * Creates an icon button that when clicked, will send a request to terminate shell command execution intermittently.
     *
     * @param containerElement
     * @param processTerminator A callback that will actually terminate the shell command execution process.
     */
    createRequestTerminatingButton(containerElement, processTerminator) {
        const button = containerElement.createEl('a', {
            prepend: true,
            attr: {
                "aria-label": "Request to terminate the process",
                class: "SC-icon-terminate-process",
            },
        });
        obsidian.setIcon(button, "power");
        button.onclick = (event) => {
            processTerminator();
            event.preventDefault();
            event.stopPropagation();
        };
    }
}
/**
 * Defines the settings structure version. Change this when a new plugin version is released, but only if that plugin
 * version introduces changes to the settings structure. Do not change if the settings structure stays unchanged.
 */
SC_Plugin.SettingsVersion = "0.18.0";
SC_Plugin.SHELL_COMMANDS_URI_ACTION = "shell-commands";

module.exports = SC_Plugin;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["src/SC_Modal.ts","src/ConfirmationModal.ts","src/Debug.ts","src/IDGenerator.ts","src/Common.ts","src/lib/escapeRegExp.ts","src/Documentation.ts","src/variables/Variable.ts","src/variables/Variable_Output.ts","src/variables/escapers/Escaper.ts","src/variables/escapers/AllSpecialCharactersEscaper.ts","src/variables/escapers/ShEscaper.ts","src/variables/escapers/PowerShellEscaper.ts","src/variables/escapers/EscapeValue.ts","src/variables/Variable_Clipboard.ts","src/variables/EditorVariable.ts","src/variables/Variable_CaretPosition.ts","src/variables/Variable_Date.ts","src/variables/VariableHelpers.ts","src/variables/FileVariable.ts","src/variables/Variable_FileExtension.ts","src/variables/Variable_FileName.ts","src/variables/Variable_FilePath.ts","src/variables/FolderVariable.ts","src/variables/Variable_FolderName.ts","src/variables/Variable_FolderPath.ts","src/variables/Variable_Selection.ts","src/variables/Variable_Tags.ts","src/variables/Variable_Title.ts","src/variables/Variable_VaultPath.ts","src/variables/Variable_Workspace.ts","src/variables/Variable_Passthrough.ts","src/variables/Variable_YAMLValue.ts","src/variables/event_variables/EventVariable.ts","src/events/SC_Event.ts","src/events/SC_WorkspaceEvent.ts","src/events/SC_MenuEvent.ts","src/events/SC_AbstractFileMenuEvent.ts","src/events/SC_Event_FileMenu.ts","src/events/SC_VaultEvent.ts","src/events/SC_Event_FileCreated.ts","src/events/SC_Event_FileContentModified.ts","src/events/SC_Event_FileDeleted.ts","src/events/SC_VaultMoveOrRenameEvent.ts","src/events/SC_Event_FileRenamed.ts","src/events/SC_Event_FileMoved.ts","src/variables/event_variables/Variable_EventFileName.ts","src/variables/event_variables/Variable_EventFilePath.ts","src/events/SC_Event_FolderMenu.ts","src/events/SC_Event_FolderCreated.ts","src/events/SC_Event_FolderDeleted.ts","src/events/SC_Event_FolderRenamed.ts","src/events/SC_Event_FolderMoved.ts","src/variables/event_variables/Variable_EventFolderName.ts","src/variables/event_variables/Variable_EventFolderPath.ts","src/variables/event_variables/Variable_EventTitle.ts","src/variables/event_variables/Variable_EventFileExtension.ts","src/variables/event_variables/Variable_EventTags.ts","src/variables/event_variables/Variable_EventYAMLValue.ts","src/variables/Variable_Environment.ts","src/variables/event_variables/Variable_EventOldFileName.ts","src/variables/event_variables/Variable_EventOldFilePath.ts","src/variables/event_variables/Variable_EventOldFolderName.ts","src/variables/event_variables/Variable_EventOldFolderPath.ts","src/variables/event_variables/Variable_EventOldTitle.ts","src/variables/Variable_NewNoteFolderName.ts","src/variables/Variable_NewNoteFolderPath.ts","src/variables/Variable_FileURI.ts","src/variables/event_variables/Variable_EventFileURI.ts","src/variables/Variable_NoteContent.ts","src/variables/event_variables/Variable_EventNoteContent.ts","src/variables/Variable_FileContent.ts","src/variables/event_variables/Variable_EventFileContent.ts","src/variables/Variable_CaretParagraph.ts","src/variables/Variable_Newline.ts","src/variables/Variable_YAMLContent.ts","src/variables/event_variables/Variable_EventYAMLContent.ts","src/variables/loadVariables.ts","src/variables/parseVariables.ts","src/output_channels/OutputChannel.ts","src/output_channels/OutputChannel_Notification.ts","src/output_channels/OutputChannel_CurrentFile.ts","src/output_channels/OutputChannel_CurrentFileCaret.ts","src/output_channels/OutputChannel_CurrentFileTop.ts","src/output_channels/OutputChannel_StatusBar.ts","src/output_channels/OutputChannel_CurrentFileBottom.ts","src/output_channels/OutputChannel_Clipboard.ts","src/Hotkeys.ts","src/output_channels/OutputChannel_Modal.ts","src/output_channels/OutputChannel_OpenFiles.ts","src/output_channels/OutputChannelFunctions.ts","src/Shell.ts","src/settings/SC_MainSettings.ts","src/ShellCommandExecutor.ts","src/models/Instance.ts","src/models/Model.ts","src/models/output_wrapper/OutputWrapper.ts","node_modules/autocompleter/autocomplete.js","src/variables/getVariableAutocompleteItems.ts","src/settings/setting_elements/Autocomplete.ts","src/models/output_wrapper/OutputWrapperSettingsModal.ts","src/models/output_wrapper/OutputWrapperModel.ts","src/models/models.ts","src/variables/CustomVariable.ts","src/models/custom_variable/CustomVariableInstance.ts","src/events/SC_Event_onLayoutReady.ts","src/events/SC_Event_onQuit.ts","src/events/SC_Event_onActiveLeafChanged.ts","src/events/SC_Event_EveryNSeconds.ts","src/events/SC_Event_EditorMenu.ts","src/events/SC_EventList.ts","src/Icons.ts","src/TShellCommand.ts","src/settings/setting_elements/createVariableDefaultValueFields.ts","src/models/custom_variable/CustomVariableModel.ts","src/models/custom_variable/CustomVariableSettingsModal.ts","src/models/custom_variable/CustomVariableView.ts","src/preactions/Preaction.ts","src/preactions/Preaction_Prompt.ts","src/models/prompt/prompt_fields/PromptField.ts","src/models/prompt/prompt_fields/PromptFieldModel.ts","src/models/prompt/prompt_fields/PromptField_Text.ts","src/models/prompt/Prompt.ts","src/models/prompt/PromptModal.ts","src/models/prompt/PromptModel.ts","src/models/createNewModelInstanceButton.ts","src/models/prompt/PromptSettingsModal.ts","src/settings/setting_elements/PathEnvironmentVariableFunctions.ts","src/variables/ParsingProcess.ts","src/settings/ShellCommandConfiguration.ts","src/Migrations.ts","src/settings/setting_elements/CreateShellSelectionField.ts","src/settings/setting_elements/multilineField.ts","src/settings/setting_elements/CreateShellCommandFieldCore.ts","src/settings/setting_elements/CreatePlatformSpecificShellCommandField.ts","src/settings/setting_elements/Tabs.ts","src/settings/ExtraOptionsModal.ts","src/settings/DeleteModal.ts","src/settings/setting_elements/CreateShellCommandField.ts","src/settings/SC_MainSettingsTab.ts","src/lib/version_compare.ts","src/main.ts"],"sourcesContent":["/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Modal} from \"obsidian\";\r\nimport SC_Plugin from \"./main\";\r\n\r\nexport abstract class SC_Modal extends Modal {\r\n\r\n    private _isOpen = false;\r\n\r\n    protected constructor (\r\n        protected readonly plugin: SC_Plugin\r\n    ) {\r\n        super(plugin.app);\r\n    }\r\n\r\n    public onOpen(): void {\r\n        this._isOpen = true;\r\n\r\n        // Make the modal scrollable if it has more content than what fits in the screen.\r\n        this.modalEl.addClass(\"SC-modal\", \"SC-scrollable\");\r\n\r\n        // Approve the modal by pressing the enter key (if enabled).\r\n        if (this.plugin.settings.approve_modals_by_pressing_enter_key) {\r\n            this.scope.register([], \"enter\", (event: KeyboardEvent) => {\r\n                // Check that no textarea is focused and no autocomplete menu is open.\r\n                if (\r\n                    0 === document.querySelectorAll(\"textarea:focus\").length &&\r\n                    0 === document.querySelectorAll(\"div.SC-autocomplete\").length\r\n                ) {\r\n                    // No textareas with focus and no open autocomplete menus were found.\r\n                    this.approve();\r\n                    event.preventDefault();\r\n                    event.stopPropagation();\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n    public isOpen() {\r\n        return this._isOpen;\r\n    }\r\n\r\n    protected setTitle(title: string) {\r\n        this.titleEl.innerText = title;\r\n    }\r\n\r\n    /**\r\n     * Called after a user presses the enter key (if approving modals by enter key press is enabled in settings). The purpose\r\n     * of the method is to approve/perform the action the modal is asking/preparing. The method should then close the modal\r\n     * by calling this.close() .\r\n     * @protected\r\n     */\r\n    protected abstract approve(): void;\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Modal} from \"./SC_Modal\";\r\nimport SC_Plugin from \"./main\";\r\nimport {Setting} from \"obsidian\";\r\n\r\nexport class ConfirmationModal extends SC_Modal {\r\n\r\n    public promise: Promise<boolean>;\r\n    private resolve_promise: (value: (boolean | PromiseLike<boolean>)) => void;\r\n    private approved = false;\r\n\r\n    constructor(\r\n        plugin: SC_Plugin,\r\n        title: string,\r\n        private question: string,\r\n        private yes_button_text: string,\r\n    ) {\r\n        super(plugin);\r\n        this.setTitle(title);\r\n        this.promise = new Promise<boolean>((resolve) => {\r\n            this.resolve_promise = resolve;\r\n        });\r\n    }\r\n\r\n    public onOpen(): void {\r\n        super.onOpen();\r\n\r\n        // Display the question\r\n        this.modalEl.createEl(\"p\", {text: this.question});\r\n\r\n        // Display the yes button\r\n        new Setting(this.modalEl)\r\n            .addButton(button => button\r\n                .setButtonText(this.yes_button_text)\r\n                .onClick(() => this.approve())\r\n            )\r\n        ;\r\n\r\n    }\r\n\r\n    protected approve(): void {\r\n        // Got a confirmation from a user\r\n        this.resolve_promise(true);\r\n        this.approved = true;\r\n        this.close();\r\n    }\r\n\r\n    public onClose(): void {\r\n        super.onClose();\r\n\r\n        if (!this.approved) { // TODO: Find out if there is a way to not use this kind of flag property. Can the status be checked from the promise itself?\r\n            this.resolve_promise(false);\r\n        }\r\n    }\r\n}","\r\n/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\n/**\r\n * If true, logging stuff to console.log() will be enabled.\r\n * Might also enable some testing {{variables}} in the future, perhaps.\r\n */\r\nexport let DEBUG_ON = false;\r\n\r\nexport function setDEBUG_ON(value: boolean) {\r\n    DEBUG_ON = value;\r\n}\r\n\r\n/**\r\n * Calls console.log(), but only if debugging is enabled.\r\n * @param message\r\n */\r\nexport function debugLog(message: unknown) {\r\n    if (DEBUG_ON) {\r\n        console.log(message);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {debugLog} from \"./Debug\";\r\n\r\nexport class IDGenerator {\r\n    constructor(\r\n        private reserved_ids: string[] = [],\r\n        private readonly min_length = 10,\r\n        private readonly characters = \"abcdefghijklmnopqrstuvwxyz0123456789\",\r\n    ) {}\r\n\r\n    public addReservedID(id: string) {\r\n        debugLog(IDGenerator.name + \": Adding id \" + id + \" to the list of reserved ids.\");\r\n        this.reserved_ids.push(id);\r\n    }\r\n\r\n    public generateID(): string {\r\n        let generated_id = \"\";\r\n        while (generated_id.length < this.min_length || this.isIDReserved(generated_id)) {\r\n            generated_id += this.generateCharacter();\r\n        }\r\n        this.reserved_ids.push(generated_id);\r\n        debugLog(IDGenerator.name + \": Generated id \" + generated_id);\r\n        return generated_id;\r\n    }\r\n\r\n    public getReservedIDs() {\r\n        return this.reserved_ids;\r\n    }\r\n\r\n    private generateCharacter(): string {\r\n        return this.characters.charAt(\r\n            Math.floor(Math.random() * this.characters.length)\r\n        );\r\n    }\r\n\r\n    private isIDReserved(id: string): boolean {\r\n        return this.reserved_ids.contains(id);\r\n    }\r\n}\r\n\r\nconst id_generator: IDGenerator = new IDGenerator();\r\n\r\nexport function getIDGenerator() {\r\n    return id_generator;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    App,\r\n    Editor,\r\n    EditorPosition,\r\n    FileSystemAdapter,\r\n    FrontMatterCache,\r\n    MarkdownView,\r\n    normalizePath,\r\n    TFile,\r\n} from \"obsidian\";\r\nimport {PlatformId} from \"./settings/SC_MainSettings\";\r\nimport {platform} from \"os\";\r\nimport * as path from \"path\";\r\nimport {debugLog} from \"./Debug\";\r\nimport SC_Plugin from \"./main\";\r\n// @ts-ignore\r\nimport {shell} from \"electron\";\r\n// @ts-ignore Electron is installed.\r\nimport {clipboard} from \"electron\";\r\n\r\nexport function getVaultAbsolutePath(app: App) {\r\n    // Original code was copied 2021-08-22 from https://github.com/phibr0/obsidian-open-with/blob/84f0e25ba8e8355ff83b22f4050adde4cc6763ea/main.ts#L66-L67\r\n    // But the code has been rewritten 2021-08-27 as per https://github.com/obsidianmd/obsidian-releases/pull/433#issuecomment-906087095\r\n    const adapter = app.vault.adapter;\r\n    if (adapter instanceof FileSystemAdapter) {\r\n        return adapter.getBasePath();\r\n    }\r\n    throw new Error(\"Could not retrieve vault path. No DataAdapter was found from app.vault.adapter.\");\r\n}\r\n\r\nexport function getPluginAbsolutePath(plugin: SC_Plugin) {\r\n    return normalizePath2(path.join(\r\n        getVaultAbsolutePath(plugin.app),\r\n        plugin.app.vault.configDir,\r\n        \"plugins\",\r\n        plugin.getPluginId()));\r\n}\r\n\r\n/**\r\n * For some reason there is no Platform.isWindows .\r\n */\r\nexport function isWindows() {\r\n    return process.platform === \"win32\";\r\n}\r\n\r\n/**\r\n * This is just a wrapper around platform() in order to cast the type to PlatformId.\r\n * TODO: Consider renaming this to getPlatformId().\r\n */\r\nexport function getOperatingSystem(): PlatformId  {\r\n    // @ts-ignore In theory, platform() can return an OS name not included in OperatingSystemName. But as Obsidian\r\n    // currently does not support anything else than Windows, Mac and Linux (except mobile platforms, but they are\r\n    // ruled out by the manifest of this plugin), it should be safe to assume that the current OS is one of those\r\n    // three.\r\n    return platform();\r\n}\r\n\r\nexport function getView(app: App) {\r\n    const view = app.workspace.getActiveViewOfType(MarkdownView);\r\n    if (!view) {\r\n        debugLog(\"getView(): Could not get a view. Will return null.\");\r\n        return null;\r\n    }\r\n    return view;\r\n}\r\n\r\nexport function getEditor(app: App): Editor | null {\r\n\r\n    const view = getView(app);\r\n    if (null === view) {\r\n        // Could not get a view.\r\n        return null;\r\n    }\r\n\r\n    // Ensure that view.editor exists! It exists at least if this is a MarkDownView.\r\n    if (\"editor\" in view) {\r\n        // Good, it exists.\r\n        // @ts-ignore We already know that view.editor exists.\r\n        return view.editor;\r\n    }\r\n\r\n    // Did not find an editor.\r\n    debugLog(\"getEditor(): 'view' does not have a property named 'editor'. Will return null.\");\r\n    return null;\r\n}\r\n\r\n// eslint-disable-next-line @typescript-eslint/ban-types\r\nexport function cloneObject<ObjectType>(object: Object): ObjectType{\r\n    return Object.assign({}, object) as ObjectType;\r\n}\r\n\r\n/**\r\n * Merges two or more objects together. If they have same property names, former objects' properties get overwritten by later objects' properties.\r\n *\r\n * @param objects\r\n */\r\n// eslint-disable-next-line @typescript-eslint/ban-types\r\nexport function combineObjects(...objects: Object[]) {\r\n    return Object.assign({}, ...objects);\r\n}\r\n\r\nexport function mergeSets<SetType>(set1: Set<SetType>, set2: Set<SetType>): Set<SetType> {\r\n    return new Set<SetType>([...set1, ...set2]);\r\n}\r\n\r\n/**\r\n * Returns a new Set cloned from 'from_set', with all items presented in 'remove' removed from it.\r\n *\r\n * @param from_set\r\n * @param remove Can be either a Set of removable items, or a single item.\r\n */\r\nexport function removeFromSet<SetType>(from_set: Set<SetType>, remove: Set<SetType> | SetType): Set<SetType> {\r\n    const reduced_set = new Set(from_set);\r\n    if (remove instanceof Set) {\r\n        for (const removable of remove) {\r\n            reduced_set.delete(removable);\r\n        }\r\n    } else {\r\n        reduced_set.delete(remove);\r\n    }\r\n    return reduced_set;\r\n}\r\n\r\n/**\r\n * Same as normalizePath(), but fixes these glitches:\r\n * - Leading forward slashes / backward slashes should not be removed.\r\n * - \\ should not be converted to / if platform is Windows. In other words, / should be converted to \\ if platform is Windows.\r\n *\r\n * TODO: I've opened a discussion about this on Obsidian's forums. If anything new comes up in the discussion, make changes accordingly. https://forum.obsidian.md/t/normalizepath-removes-a-leading/24713\r\n */\r\nexport function normalizePath2(path: string) {\r\n    // 1. Preparations\r\n    path = path.trim();\r\n    const leading_slashes_regexp = /^[/\\\\]*/gu; // Get as many / or \\ slashes as there are in the very beginning of path. Can also be \"\" (an empty string).\r\n    const leading_slashes_array = leading_slashes_regexp.exec(path); // An array with only one item.\r\n    if (null === leading_slashes_array) {\r\n        // It should always match. This exception should never happen, but have it just in case.\r\n        throw new Error(\"normalizePath2(): leading_slashes_regexp did not match.\");\r\n    }\r\n    let leading_slashes = leading_slashes_array[0];\r\n\r\n    // 2. Run the original normalizePath()\r\n    path = normalizePath(path);\r\n\r\n    // 3. Fixes\r\n    // Check that correct slashes are used.\r\n    if (isWindows()) {\r\n        // The platform is Windows.\r\n        // Convert / to \\\r\n        path = path.replace(/\\//gu, \"\\\\\"); // Need to use a regexp instead of a normal \"/\" -> \"\\\\\" replace because the normal replace would only replace first occurrence of /.\r\n        leading_slashes = leading_slashes.replace(/\\//gu, \"\\\\\"); // Same here.\r\n    }\r\n    // Now ensure that path still contains leading slashes (if there were any before calling normalizePath()).\r\n    // Check that the path should have a similar set of leading slashes at the beginning. It can be at least \"/\" (on linux/Mac), or \"\\\\\" (on Windows when it's a network path), in theory even \"///\" or \"\\\\\\\\\\\" whatever.\r\n    // normalizePath() seems to remove leading slashes (and they are needed to be re-added), but it's needed to check first, otherwise the path would have double leading slashes if normalizePath() gets fixed in the future.\r\n    if (leading_slashes.length && path.slice(0, leading_slashes.length) !== leading_slashes) {\r\n        // The path does not contain the required set of leading slashes, so add them.\r\n        path = leading_slashes + path;\r\n    }\r\n\r\n    // 4. Done\r\n    return path;\r\n}\r\n\r\nexport function extractFileName(file_path: string, with_extension = true) {\r\n    if (with_extension) {\r\n        return path.parse(file_path).base;\r\n    } else {\r\n        return path.parse(file_path).name;\r\n    }\r\n}\r\n\r\nexport function extractFileParentPath(file_path: string) {\r\n    return path.parse(file_path).dir;\r\n}\r\n\r\n// eslint-disable-next-line @typescript-eslint/ban-types\r\nexport function joinObjectProperties(object: {}, glue: string) {\r\n    let result = \"\";\r\n    for (const property_name in object) {\r\n        if (result.length) {\r\n            result += glue;\r\n        }\r\n        // @ts-ignore\r\n        result += object[property_name];\r\n    }\r\n    return result;\r\n}\r\n\r\n/**\r\n * Removes all duplicates from an array.\r\n *\r\n * Idea is copied 2021-10-06 from https://stackoverflow.com/a/33121880/2754026\r\n */\r\nexport function uniqueArray(array: any[]) {\r\n    return [...new Set(array)];\r\n}\r\n\r\n/**\r\n * Opens a web browser in the specified URL.\r\n * @param url\r\n */\r\nexport function gotoURL(url: string) {\r\n    shell.openExternal(url); // This returns a promise, but it can be ignored as there's nothing to do after opening the browser.\r\n}\r\n\r\nexport function generateObsidianCommandName(plugin: SC_Plugin, shell_command: string, alias: string) {\r\n    const prefix = plugin.settings.obsidian_command_palette_prefix;\r\n    if (alias) {\r\n        // If an alias is set for the command, Obsidian's command palette should display the alias text instead of the actual command.\r\n        return prefix + alias;\r\n    }\r\n    return prefix + shell_command;\r\n}\r\n\r\nexport function isInteger(value: string, allow_minus: boolean): boolean {\r\n    if (allow_minus) {\r\n        return !!value.match(/^-?\\d+$/u);\r\n    } else {\r\n        return !!value.match(/^\\d+$/u);\r\n    }\r\n}\r\n\r\n/**\r\n * Translates 1-indexed caret line and column to a 0-indexed EditorPosition object. Also translates a possibly negative line\r\n * to a positive line from the end of the file, and a possibly negative column to a positive column from the end of the line.\r\n * @param editor\r\n * @param caret_line\r\n * @param caret_column\r\n */\r\nexport function prepareEditorPosition(editor: Editor, caret_line: number, caret_column: number): EditorPosition {\r\n    // Determine line\r\n    if (caret_line < 0) {\r\n        // Negative line means to calculate it from the end of the file.\r\n        caret_line = Math.max(0, editor.lastLine() + caret_line + 1);\r\n    } else {\r\n        // Positive line needs just a small adjustment.\r\n        // Editor line is zero-indexed, line numbers are 1-indexed.\r\n        caret_line -= 1;\r\n    }\r\n\r\n    // Determine column\r\n    if (caret_column < 0) {\r\n        // Negative column means to calculate it from the end of the line.\r\n        caret_column = Math.max(0, editor.getLine(caret_line).length + caret_column + 1);\r\n    } else {\r\n        // Positive column needs just a small adjustment.\r\n        // Editor column is zero-indexed, column numbers are 1-indexed.\r\n        caret_column -= 1;\r\n    }\r\n\r\n    return {\r\n        line: caret_line,\r\n        ch: caret_column,\r\n    };\r\n}\r\n\r\nexport function getSelectionFromTextarea(textarea_element: HTMLTextAreaElement, return_null_if_empty: true): string | null;\r\nexport function getSelectionFromTextarea(textarea_element: HTMLTextAreaElement, return_null_if_empty: false): string;\r\nexport function getSelectionFromTextarea(textarea_element: HTMLTextAreaElement, return_null_if_empty: boolean): string | null {\r\n    const selected_text = textarea_element.value.substring(textarea_element.selectionStart, textarea_element.selectionEnd);\r\n    return \"\" === selected_text && return_null_if_empty ? null : selected_text;\r\n}\r\n\r\n/**\r\n * Creates an HTMLElement (with freely decidable tag) and adds the given content into it as normal text. No HTML formatting\r\n * is supported, i.e. possible HTML special characters are shown as-is. Newline characters are converted to <br> elements.\r\n *\r\n * @param tag\r\n * @param content\r\n * @param parent_element\r\n */\r\nexport function createMultilineTextElement(tag: keyof HTMLElementTagNameMap, content: string, parent_element: HTMLElement) {\r\n    const content_element = parent_element.createEl(tag);\r\n\r\n    // Insert content line-by-line\r\n    const content_lines = content.split(/\\r\\n|\\r|\\n/g); // Don't use ( ) with | because .split() would then include the newline characters in the resulting array.\r\n    content_lines.forEach((content_line: string, content_line_index: number) => {\r\n        // Insert the line.\r\n        content_element.insertAdjacentText(\"beforeend\", content_line);\r\n\r\n        // Insert a linebreak <br> if needed.\r\n        if (content_line_index < content_lines.length - 1) {\r\n            content_element.insertAdjacentHTML(\"beforeend\", \"<br>\");\r\n        }\r\n    });\r\n    return content_element;\r\n}\r\n\r\nexport function randomInteger(min: number, max: number) {\r\n    const range = max - min + 1;\r\n    return min + Math.floor(Math.random() * range);\r\n}\r\n\r\n/**\r\n * Does the following prefixings:\r\n *   \\ will become \\\\\r\n *   [ will become \\[\r\n *   ] will become \\]\r\n *   ( will become \\(\r\n *   ) will become \\)\r\n *\r\n * @param content\r\n */\r\nexport function escapeMarkdownLinkCharacters(content: string) {\r\n    // TODO: \\[ can be replaced with [ as eslint suggests and ten remove the ignore line below. I'm not doing it now because it would be outside of the scope of this commit/issue #70.\r\n    // eslint-disable-next-line no-useless-escape\r\n    return content.replace(/[\\\\()\\[\\]]/gu, \"\\\\$&\");\r\n}\r\n\r\nexport function copyToClipboard(text: string): Promise<void> {\r\n    return clipboard.writeText(text);\r\n}\r\n\r\nexport async function getFileContentWithoutYAML(app: App, file: TFile): Promise<string> {\r\n    return new Promise((resolve) => {\r\n        // The logic is borrowed 2022-09-01 from https://forum.obsidian.md/t/how-to-get-current-file-content-without-yaml-frontmatter/26197/2\r\n        // Thank you, endorama! <3\r\n        const file_content = app.vault.read(file);\r\n        file_content.then((file_content: string) => {\r\n            const frontmatter_cache: FrontMatterCache | undefined = app.metadataCache.getFileCache(file)?.frontmatter;\r\n            if (frontmatter_cache) {\r\n                // A YAML frontmatter is present in the file.\r\n                const frontmatter_end_line_number = frontmatter_cache.position.end.line + 1; // + 1: Take the last --- line into account, too.\r\n                const file_content_without_frontmatter: string = file_content.split(\"\\n\").slice(frontmatter_end_line_number).join(\"\\n\");\r\n                return resolve(file_content_without_frontmatter);\r\n            } else {\r\n                // No YAML frontmatter is present in the file.\r\n                // Return the whole file content, because there's nothing to remove.\r\n                return resolve(file_content);\r\n            }\r\n        });\r\n    });\r\n}\r\n\r\nexport async function getFileYAML(app: App, file: TFile, withDashes: boolean): Promise<string | null> {\r\n    return new Promise((resolve) => {\r\n        // The logic is borrowed 2022-09-01 from https://forum.obsidian.md/t/how-to-get-current-file-content-without-yaml-frontmatter/26197/2\r\n        // Thank you, endorama! <3\r\n        const fileContent = app.vault.read(file);\r\n        fileContent.then((file_content: string) => {\r\n            const frontmatterCache: FrontMatterCache | undefined = app.metadataCache.getFileCache(file)?.frontmatter;\r\n            if (frontmatterCache) {\r\n                // A YAML frontmatter is present in the file.\r\n                const frontmatterEndLineNumber = frontmatterCache.position.end.line + 1; // + 1: Take the last --- line into account, too.\r\n                let firstLine: number;\r\n                let lastLine: number;\r\n                if (withDashes) {\r\n                    // Take full YAML content, including --- lines at the top and bottom.\r\n                    firstLine = 0;\r\n                    lastLine = frontmatterEndLineNumber;\r\n                } else {\r\n                    // Exclude --- lines.\r\n                    firstLine = 1;\r\n                    lastLine = frontmatterEndLineNumber-1;\r\n                }\r\n                const frontmatterContent: string = file_content.split(\"\\n\").slice(firstLine,lastLine).join(\"\\n\");\r\n                return resolve(frontmatterContent);\r\n            } else {\r\n                // No YAML frontmatter is present in the file.\r\n                return resolve(null);\r\n            }\r\n        });\r\n    });\r\n}","\r\n/**\r\n * Escapes a string that will be used as a pattern in a regular expression.\r\n *\r\n * Note that this does not escape minus: - . It's probably ok as long as you won't wrap the result of this function in square brackets [ ] . For more information, read a comment by coolaj86 on Nov 29, 2019 at 2:44 in this Stack Overflow answer: https://stackoverflow.com/a/6969486/2754026\r\n *\r\n * Copied 2022-03-10 from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping\r\n * Modifications:\r\n *  - Added TypeScript data type hints for the parameter and return value.\r\n *  - Added 'export' keyword.\r\n *  - Added this JSDoc.\r\n *  - No other changes.\r\n *\r\n * @param string\r\n * @return string\r\n */\r\nexport function escapeRegExp(string: string): string {\r\n    return string.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'); // $& means the whole matched string\r\n}\r\n","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nexport const DocumentationMainLink = \"https://publish.obsidian.md/shellcommands\";\r\nexport const DocumentationBuiltInVariablesBaseLink = \"https://publish.obsidian.md/shellcommands/Variables/\"; // When used, a variable's name will be appended to the end. Keep the trailing slash!\r\nexport const DocumentationBuiltInVariablesIndexLink = \"https://publish.obsidian.md/shellcommands/Variables/Variables+-+general+principles#All+variables\";\r\nexport const DocumentationCustomVariablesLink = \"https://publish.obsidian.md/shellcommands/Variables/Custom+variables\";\r\nexport const DocumentationAutocompleteLink = \"https://publish.obsidian.md/shellcommands/Variables/Autocomplete/Autocomplete\";\r\nexport const DocumentationEventsFolderLink = \"https://publish.obsidian.md/shellcommands/Events/\";\r\nexport const DocumentationPATHAugmentationsLink = \"https://publish.obsidian.md/shellcommands/Environments/Additions+to+the+PATH+environment+variable\";\r\nexport const DocumentationOutputWrappersLink = \"https://publish.obsidian.md/shellcommands/Output+handling/Output+wrappers\";\r\nexport const DocumentationOutputHandlingModeLink = \"https://publish.obsidian.md/shellcommands/Output+handling/Realtime+output+handling\";\r\nexport const DocumentationStdinContentLink = \"https://publish.obsidian.md/shellcommands/Variables/Pass+variables+to+stdin\";\r\nexport const GitHubLink = \"https://github.com/Taitava/obsidian-shellcommands\";\r\nexport const ChangelogLink = \"https://github.com/Taitava/obsidian-shellcommands/blob/main/CHANGELOG.md\";\r\nexport const LicenseLink = \"https://github.com/Taitava/obsidian-shellcommands/blob/main/LICENSE\";","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {App} from \"obsidian\";\r\nimport SC_Plugin from \"../main\";\r\nimport {IAutocompleteItem} from \"../settings/setting_elements/Autocomplete\";\r\nimport {SC_Event} from \"../events/SC_Event\";\r\nimport {escapeRegExp} from \"../lib/escapeRegExp\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {debugLog} from \"../Debug\";\r\nimport {ParsingResult} from \"./parseVariables\";\r\nimport {DocumentationBuiltInVariablesBaseLink} from \"../Documentation\";\r\nimport {EOL} from \"os\";\r\n\r\n/**\r\n * Variables that can be used to inject values to shell commands using {{variable:argument}} syntax.\r\n */\r\nexport abstract class Variable {\r\n    private static readonly parameter_separator = \":\";\r\n    protected readonly app: App;\r\n    public variable_name: string;\r\n    public help_text: string;\r\n\r\n    /**\r\n     * If this is false, the variable can be assigned a default value that can be used in situations where the variable is unavailable.\r\n     * TODO: Set to false, as most Variables are not always available. Then remove all 'always_available = false' lines from subclasses, and add 'always_available = true' to those subclasses that need it.\r\n     * @protected\r\n     */\r\n    protected always_available = true;\r\n\r\n    /**\r\n     * A definition for what parameters this variables takes.\r\n     * @protected\r\n     */\r\n    protected static readonly parameters: IParameters = {};\r\n\r\n    constructor(\r\n        protected readonly plugin: SC_Plugin,\r\n    ) {\r\n        this.app = plugin.app;\r\n    }\r\n\r\n    public getValue(\r\n        t_shell_command: TShellCommand | null = null,\r\n        sc_event: SC_Event | null = null,\r\n        variableArguments: IRawArguments = {},\r\n\r\n        /**\r\n         * Will parse variables in a default value (only used if this variable is not available this time). The callback\r\n         * is only used, if t_shell_command is given. Set to null, if no variable parsing is needed for default values.\r\n         * */\r\n        default_value_parser: ((content: string) => Promise<ParsingResult>) | null = null,\r\n    ): Promise<VariableValueResult> {\r\n\r\n        return new Promise<VariableValueResult>((resolve) => {\r\n            // Cast arguments (if any) to their correct data types\r\n            const castedArguments = this.castArguments(variableArguments);\r\n\r\n            // Generate a value, or catch an exception if one occurs.\r\n            this.generateValue(castedArguments, sc_event).then((value: string | null) => {\r\n                // Value generation succeeded.\r\n                return resolve({\r\n                    value: value,\r\n                    error_messages: [],\r\n                    succeeded: true,\r\n                });\r\n            }).catch((error) => {\r\n                // Caught a VariableError or an Error.\r\n                if (error instanceof VariableError) {\r\n                    // The variable is not available in this situation.\r\n                    debugLog(this.constructor.name + \".getValue(): Caught a VariableError and will determine how to handle it: \" + error.message);\r\n\r\n                    // Check what should be done.\r\n                    const default_value_configuration = t_shell_command?.getDefaultValueConfigurationForVariable(this); // The method can return undefined, and t_shell_command can be null.\r\n                    const default_value_type = default_value_configuration ? default_value_configuration.type : \"show-errors\";\r\n                    const debug_message_base = \"Variable \" + this.getFullName() + \" is not available. \";\r\n                    switch (default_value_type) {\r\n                        case \"show-errors\":\r\n                            // Generate error messages by calling generateValue().\r\n                            debugLog(debug_message_base + \"Will prevent shell command execution and show visible error messages.\");\r\n                            return resolve({\r\n                                value: null,\r\n                                error_messages: [error.message], // Currently, error_messages will never contain multiple messages. TODO: Consider renaming error_messages to singular form.\r\n                                succeeded: false,\r\n                            });\r\n                        case \"cancel-silently\":\r\n                            // Prevent execution, but do not show any errors\r\n                            debugLog(debug_message_base + \"Will prevent shell command execution silently without visible error messages.\");\r\n                            return resolve({\r\n                                value: null,\r\n                                error_messages: [],\r\n                                succeeded: false,\r\n                            });\r\n                        case \"value\":\r\n                            // Return a default value.\r\n                            if (!default_value_configuration) {\r\n                                // This should not happen, because default_value_type is never \"value\" when default_value_configuration is undefined or null.\r\n                                // This check is just for TypeScript compiler to understand that default_value_configuration is defined when it's accessed below.\r\n                                throw new Error(\"Default value configuration is undefined.\");\r\n                            }\r\n                            debugLog(debug_message_base + \"Will use a default value: \" + default_value_configuration.value);\r\n                            if (default_value_parser) {\r\n                                // Parse possible variables in the default value.\r\n                                default_value_parser(default_value_configuration.value).then((default_value_parsing_result: ParsingResult) => {\r\n                                    return resolve({\r\n                                        value:\r\n                                            default_value_parsing_result.succeeded\r\n                                                ? default_value_parsing_result.parsed_content\r\n                                                : default_value_parsing_result.original_content\r\n                                        ,\r\n                                        error_messages: default_value_parsing_result.error_messages,\r\n                                        succeeded: default_value_parsing_result.succeeded,\r\n                                    });\r\n                                });\r\n\r\n                            } else {\r\n                                // No variable parsing is wanted.\r\n                                return resolve({\r\n                                    value: default_value_configuration.value,\r\n                                    error_messages: [],\r\n                                    succeeded: true,\r\n                                });\r\n                            }\r\n                            break;\r\n                        default:\r\n                            throw new Error(\"Unrecognised default value type: \" + default_value_type);\r\n                    }\r\n                } else {\r\n                    // A program logic error has happened.\r\n                    debugLog(this.constructor.name + \".getValue(): Caught an unrecognised error of class: \" + error.constructor.name + \". Will rethrow it.\");\r\n                    throw error;\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * TODO: Consider can the sc_event parameter be moved so that it would only exist in EventVariable and it's child classes? Same for getValue() method.\r\n     */\r\n    protected abstract generateValue(variableArguments: ICastedArguments, sc_event: SC_Event | null): Promise<string>;\r\n\r\n    protected getParameters() {\r\n        const child_class = this.constructor as typeof Variable;\r\n        return child_class.parameters;\r\n    }\r\n\r\n    private getParameterSeparator() {\r\n        const child_class = this.constructor as typeof Variable;\r\n        return child_class.parameter_separator;\r\n    }\r\n\r\n    public getPattern() {\r\n        const error_prefix = this.variable_name + \".getPattern(): \";\r\n        let pattern = '\\\\{\\\\{!?' + escapeRegExp(this.variable_name);\r\n        for (const parameter_name in this.getParameters()) {\r\n            const parameter = this.getParameters()[parameter_name];\r\n            let parameter_type_pattern: string = this.getParameterSeparator();  // Here this.parameter_separator (= : ) is included in the parameter value just so that it's not needed to do nested parenthesis to accomplish possible optionality: (:())?. parseShellCommandVariables() will remove the leading : .\r\n\r\n            // Check should we use parameter.options or parameter.type.\r\n            if (\r\n                undefined === parameter.options &&\r\n                undefined === parameter.type\r\n            ) {\r\n                // Neither is defined :(\r\n                throw Error(error_prefix + \"Parameter '\" + parameter_name + \"' should define either 'type' or 'options', neither is defined!\");\r\n            } else if (\r\n                undefined !== parameter.options &&\r\n                undefined !== parameter.type\r\n            ) {\r\n                // Both are defined :(\r\n                throw Error(error_prefix + \"Parameter '\" + parameter_name + \"' should define either 'type' or 'options', not both!\");\r\n            } else if (undefined !== parameter.options) {\r\n                // Use parameter.options\r\n                parameter_type_pattern += parameter.options.join(\"|\" + this.getParameterSeparator()); // E.g. \"absolute|:relative\" for {{file_path:mode}} variable's 'mode' parameter.\r\n            } else {\r\n                // Use parameter.type\r\n                switch (parameter.type) {\r\n                    case \"string\":\r\n                        parameter_type_pattern += \".*?\";\r\n                        break;\r\n                    case \"integer\":\r\n                        parameter_type_pattern += \"\\\\d+\";\r\n                        break;\r\n                    default:\r\n                        throw Error(error_prefix + \"Parameter '\" + parameter_name + \"' has an unrecognised type: \" + parameter.type);\r\n                }\r\n            }\r\n\r\n            // Add the subpattern to 'pattern'.\r\n            pattern += \"(\" + parameter_type_pattern + \")\";\r\n            if (!parameter.required) {\r\n                // Make the parameter optional.\r\n                pattern += \"?\";\r\n            }\r\n\r\n        }\r\n        pattern += '\\\\}\\\\}';\r\n        return pattern;\r\n    }\r\n\r\n    public getParameterNames() {\r\n        return Object.getOwnPropertyNames(this.getParameters());\r\n    }\r\n\r\n    /**\r\n     * @param variableArguments String typed arguments. Arguments that should be typed otherly, will be cast to other types. Then all arguments are returned.\r\n     */\r\n    public castArguments(variableArguments: IRawArguments): ICastedArguments {\r\n        const castedArguments: ICastedArguments = {};\r\n        for (const parameterName of Object.getOwnPropertyNames(variableArguments)) {\r\n            const parameter_type = this.getParameters()[parameterName].type ?? \"string\"; // If the variable uses \"options\" instead of \"type\", then the type is always \"string\".\r\n            const argument = variableArguments[parameterName];\r\n            switch (parameter_type) {\r\n                case \"string\":\r\n                    castedArguments[parameterName] = argument;\r\n                    break;\r\n                case \"integer\":\r\n                    castedArguments[parameterName] = parseInt(argument);\r\n                    break;\r\n            }\r\n        }\r\n        return castedArguments;\r\n    }\r\n\r\n    /**\r\n     * Creates a VariableError and passes it to a rejector function, which will pass the VariableError to Variable.getValue().\r\n     * Then it will be handled there according to user preferences.\r\n     *\r\n     * @param message\r\n     * @param rejector\r\n     * @protected\r\n     */\r\n    protected reject(message: string, rejector: (error: VariableError) => void): void {\r\n        rejector(this.newVariableError(message));\r\n    }\r\n\r\n    /**\r\n     * Similar to Variable.reject(), but uses a traditional throw. Can be used in async methods. For methods that create\r\n     * Promises manually, Variable.reject() should be used, because errors thrown in manually created Promises are not caught\r\n     * by Variable.getValue()'s Promise.catch() callback.\r\n     *\r\n     * @param message\r\n     * @protected\r\n     */\r\n    protected throw(message: string): never {\r\n        throw this.newVariableError(message);\r\n    }\r\n\r\n    private newVariableError(message: string) {\r\n        const prefix = this.getFullName() + \": \";\r\n        return new VariableError(prefix + message);\r\n    }\r\n\r\n    public getAutocompleteItems(): IAutocompleteItem[] {\r\n\r\n        // Check if the variable has at least one _mandatory_ parameter.\r\n        let parameter_indicator = \"\";\r\n        const parameter_names =\r\n            Object.getOwnPropertyNames(this.getParameters())\r\n                .filter(parameter_name => this.getParameters()[parameter_name].required === true) // Only include mandatory parameters\r\n        ;\r\n        if (parameter_names.length > 0) {\r\n            parameter_indicator = Variable.parameter_separator; // When the variable name ends with a parameter separator character, it indicates to a user that an argument should be supplied.\r\n        }\r\n\r\n        return [\r\n            // Normal variable\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + parameter_indicator + \"}}\",\r\n                help_text: (this.help_text + \" \" + this.getAvailabilityText()).trim(), // .trim() removes \" \" if help_text or getAvailabilityText() is empty.\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped version of the variable\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + parameter_indicator + \"}}\",\r\n                help_text: (this.help_text + \" \" + this.getAvailabilityText()).trim(), // .trim() removes \" \" if help_text or getAvailabilityText() is empty.\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName() {\r\n        return \"<strong>\" + this.getFullName() + \"</strong>\";\r\n    }\r\n\r\n    /**\r\n     * Returns the Variable's name wrapped in {{ and }}.\r\n     *\r\n     * TODO: Change hardcoded {{ }} entries to use this method all around the code.\r\n     */\r\n    public getFullName(): string {\r\n        return \"{{\" + this.variable_name + \"}}\";\r\n    }\r\n\r\n    /**\r\n     * TODO: Create a class BuiltinVariable and move this method there. This should not be present for CustomVariables.\r\n     */\r\n    public getDocumentationLink(): string {\r\n        return DocumentationBuiltInVariablesBaseLink + encodeURI(this.getFullName());\r\n    }\r\n\r\n    /**\r\n     * TODO: Create a class BuiltinVariable and move this method there. This should not be present for CustomVariables.\r\n     */\r\n    public createDocumentationLinkElement(container: HTMLElement\r\n    ): void {\r\n        const description =\r\n            this.getFullName() + \": \" + this.help_text\r\n            + EOL + EOL +\r\n            \"Click for external documentation.\"\r\n        ;\r\n        container.createEl(\"a\", {\r\n            text: this.getFullName(),\r\n            href: this.getDocumentationLink(),\r\n            attr: {\"aria-label\": description},\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Returns a unique string that can be used in default value configurations.\r\n     * @return Normal variable name, if this is a built-in variable; or an ID string if this is a CustomVariable.\r\n     */\r\n    public getIdentifier(): string {\r\n        return this.getFullName();\r\n    }\r\n\r\n    /**\r\n     * This can be used to determine if the variable can sometimes be unavailable. Used in settings to allow a user to define\r\n     * default values for variables that are not always available, filtering out always available variables for which default\r\n     * values would not make sense.\r\n     */\r\n    public isAlwaysAvailable() {\r\n        return this.always_available;\r\n    }\r\n\r\n    /**\r\n     * For variables that are always available, returns an empty string.\r\n     */\r\n    public getAvailabilityText() {\r\n        return \"\";\r\n    }\r\n\r\n    /**\r\n     * Same as getAvailabilityText(), but removes HTML from the result.\r\n     */\r\n    public getAvailabilityTextPlain(): string {\r\n        return this.getAvailabilityText().replace(/<\\/?strong>/ig, \"\"); // Remove <strong> and </strong> markings from the help text\r\n    }\r\n\r\n    /**\r\n     * Returns a default value configuration object that should be used if a shell command does not define its own\r\n     * default value configuration object.\r\n     */\r\n    public getGlobalDefaultValueConfiguration(): GlobalVariableDefaultValueConfiguration | null {\r\n        // Works for built-in variables only. CustomVariable class needs to override this method and not call the parent!\r\n        return this.plugin.settings.builtin_variables[this.getIdentifier()]?.default_value; // Can return null\r\n    }\r\n}\r\n\r\n/**\r\n * Arguments that are cast to their designed data types, i.e. strings or integers at the moment.\r\n */\r\nexport interface ICastedArguments {\r\n    [key: string]: unknown;\r\n}\r\n\r\n/**\r\n * Same as ICastedArguments, but not yet cast to the target data types.\r\n */\r\nexport interface IRawArguments {\r\n    [key: string]: string;\r\n}\r\n\r\n/**\r\n * key = string, parameter name\r\n * value = boolean, is the parameter mandatory or not?\r\n */\r\nexport interface IParameters {\r\n    [key: string]: {\r\n        /** What data type is allowed. (New types can be added later). Should be omitted, if 'options' is used. */\r\n        type?: \"string\" | \"integer\";\r\n        /** This can define static values for this parameter. Should be omitted, if 'type' is used. */\r\n        options?: string[];\r\n        /** Is this parameter mandatory? */\r\n        required: boolean;\r\n    };\r\n}\r\n\r\nexport interface VariableValueResult {\r\n    value: string | null,\r\n    error_messages: string[],\r\n\r\n    /** In practise, this is true every time error_messages is empty, so this is just a shorthand so that error_messages.length does not need to be checked by the consumer. */\r\n    succeeded: boolean,\r\n}\r\n\r\n/**\r\n * Thrown when Variables encounter errors that users should solve. Variable.getValue() will catch these and show to user\r\n * (unless errors are ignored).\r\n */\r\nexport class VariableError extends Error {}\r\n\r\nexport type VariableDefaultValueType = \"show-errors\" | \"cancel-silently\" | \"value\";\r\n\r\nexport type VariableDefaultValueTypeWithInherit = VariableDefaultValueType | \"inherit\";\r\n\r\n/**\r\n * Interface for a configuration object that can opt for retrieving the configuration from an upper level by defining its\r\n * 'type' property have value 'inherit'.\r\n */\r\nexport interface InheritableVariableDefaultValueConfiguration {\r\n    type: VariableDefaultValueTypeWithInherit,\r\n    value: string,\r\n}\r\n\r\n/**\r\n * Interface for a configuration object that is on a root level and so cannot inherit configuration from an upper level,\r\n * because there is no upper level. Objects implementing this interface cannot set their 'type' property to 'inherit'.\r\n */\r\nexport interface GlobalVariableDefaultValueConfiguration {\r\n    type: VariableDefaultValueType,\r\n    value: string,\r\n}\r\n","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Variable} from \"./Variable\";\r\nimport SC_Plugin from \"../main\";\r\n\r\nexport class Variable_Output extends Variable {\r\n    public variable_name = \"output\";\r\n    public help_text = \"Gives text outputted by a shell command after it's executed.\";\r\n\r\n    constructor(\r\n        plugin: SC_Plugin,\r\n        private output_content: string,\r\n    ) {\r\n        super(plugin);\r\n    }\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        return this.output_content;\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return \"<strong>Only available</strong> in <em>output wrappers</em>, cannot be used as input for shell commands.\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nexport abstract class Escaper {\r\n    protected raw_value: string;\r\n\r\n    public constructor(raw_value: string) {\r\n        this.raw_value = raw_value;\r\n    }\r\n\r\n    public abstract escape(): string;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Escaper} from \"./Escaper\";\r\n\r\n/**\r\n * Prefixes all characters that are not letters, numbers or underscores with a prefix character that can be defined by child classes.\r\n */\r\nexport abstract class AllSpecialCharactersEscaper extends Escaper {\r\n    protected abstract prefix: string;\r\n\r\n    public escape(): string {\r\n        return this.raw_value.replace(/[^\\w\\d]/gu, (special_character: string) => {  // /g means to replace all occurrences instead of just the first one. /u means to handle four-byte unicode characters correctly as one character, not as two separate characters.\r\n            // Do the replacing in a function in order to avoid a possible $ character to be interpreted by JavaScript to interact with the regex.\r\n            // More information: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter (referenced 2021-11-02.\r\n            return this.prefix + special_character;\r\n        });\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {AllSpecialCharactersEscaper} from \"./AllSpecialCharactersEscaper\";\r\n\r\nexport class ShEscaper extends AllSpecialCharactersEscaper {\r\n    protected prefix = \"\\\\\"; // In *sh, escaping should use a backslash, e.g. \"Hello, world!\" becomes \\\"Hello\\,\\ world\\!\\\"\r\n\r\n    public escape(): string {\r\n        return this.replace_newlines(super.escape());\r\n    }\r\n\r\n    /**\r\n     * Converts escaped newline characters to a form that the Bourne family shells will interpret as literal newlines,\r\n     * not as ignorable characters.\r\n     *\r\n     * @param escaped_value\r\n     * @private\r\n     */\r\n    private replace_newlines(escaped_value: string): string {\r\n        return escaped_value\r\n            .replaceAll(this.prefix+\"\\r\", this.prefix+this.prefix+\"r\") // Replace a real linefeed with a literal \"\\\\r\".\r\n            .replaceAll(this.prefix+\"\\n\", this.prefix+this.prefix+\"n\") // Replace a real newline with a literal \"\\\\n\".\r\n        ;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {AllSpecialCharactersEscaper} from \"./AllSpecialCharactersEscaper\";\r\n\r\nexport class PowerShellEscaper extends AllSpecialCharactersEscaper {\r\n    protected prefix = \"`\"; // In PowerShell, escaping should use a ` character, e.g. \"Hello, world!\" becomes `\"Hello`,` world`!`\"\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Escaper} from \"./Escaper\";\r\nimport {ShEscaper} from \"./ShEscaper\";\r\nimport {PowerShellEscaper} from \"./PowerShellEscaper\";\r\nimport {Notice} from \"obsidian\";\r\nimport {extractFileName} from \"../../Common\";\r\n\r\nexport function escapeValue(shell: string, raw_value: string) {\r\n    shell = extractFileName(shell.toLowerCase());\r\n    let escaper: Escaper;\r\n    switch (shell) {\r\n        case \"bash\":\r\n        case \"dash\":\r\n        case \"zsh\":\r\n        case \"sh\": // May sometimes appear when using the \"Use system default (sh)\" option as a default shell.\r\n            escaper = new ShEscaper(raw_value);\r\n            break;\r\n        case \"powershell.exe\":  // PowerShell 5 is only available for Windows.\r\n        case \"pwsh.exe\":        // In Windows.\r\n        case \"pwsh\":            // In Linux and Mac. (SC does not actually support using PowerShell on Linux/Mac just yet, but support can be added).\r\n            escaper = new PowerShellEscaper(raw_value);\r\n            break;\r\n        case \"cmd.exe\":\r\n            // Exception: There is no escaping support for CMD, so all values will be left unescaped when CMD is used. :(\r\n            return raw_value;\r\n        default:\r\n            // Shell was not recognised.\r\n            new Notice(\"EscapeValue(): Unrecognised shell: \" + shell);\r\n            throw new Error(\"EscapeValue(): Unrecognised shell: \" + shell);\r\n    }\r\n    return escaper.escape();\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Variable} from \"./Variable\";\r\n// @ts-ignore \"electron\" is installed.\r\nimport {clipboard} from \"electron\";\r\n\r\nexport class Variable_Clipboard extends Variable {\r\n    public variable_name = \"clipboard\";\r\n    public help_text = \"Gives the content you last copied to your clipboard.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        return clipboard.readText();\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Variable} from \"./Variable\";\r\nimport {\r\n    getEditor,\r\n    getView,\r\n} from \"../Common\";\r\nimport {\r\n    Editor,\r\n    MarkdownView,\r\n} from \"obsidian\";\r\nimport {debugLog} from \"../Debug\";\r\n\r\nexport abstract class EditorVariable extends Variable {\r\n\r\n    protected always_available = false;\r\n\r\n    protected getEditorOrThrow(): Editor | never {\r\n        const editor = getEditor(this.app);\r\n        if (null === editor) {\r\n            // No editor.\r\n            this.throw(\"Could not get an editor instance! Please create a discussion in GitHub.\");\r\n        }\r\n        return editor;\r\n    }\r\n\r\n    /**\r\n     * Can be made protected if needed to be accessed by subclasses.\r\n     * @private\r\n     */\r\n    private getViewOrThrow(): MarkdownView {\r\n        const view = getView(this.app);\r\n        if (null === view) {\r\n            // No view.\r\n            this.throw(\"Could not get a view instance! Please create a discussion in GitHub.\");\r\n        }\r\n        return view;\r\n    }\r\n\r\n    protected requireViewModeSource(): void {\r\n        const view: MarkdownView = this.getViewOrThrow();\r\n        const view_mode = view.getMode(); // \"preview\" or \"source\" (\"live\" was removed from Obsidian API in 0.13.8 on 2021-12-10).\r\n\r\n        switch (view_mode) {\r\n            case \"preview\":\r\n                // The leaf is in preview mode, which makes things difficult.\r\n                // FIXME: Make it possible to use this feature also in preview mode.\r\n                debugLog(\"EditorVariable: 'view' is in preview mode, and the poor guy who wrote this code, does not know how to return an editor instance that could be used for getting text selection.\");\r\n                this.throw(\"You need to turn editing mode on, unfortunately this variable does not work in preview mode.\");\r\n                break;\r\n            case \"source\":\r\n                // Good, the editor is in \"source\" mode, so it's possible to get a selection, caret position or other editing related information.\r\n                return;\r\n            default:\r\n                this.throw(\"Unrecognised view mode: \" + view_mode);\r\n                break;\r\n        }\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return \"<strong>Only available</strong> when a note pane is open, not in graph view, nor when viewing non-text files.\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact:\r\n *  - Vinay Rajur: https://github.com/vrajur\r\n *  - Jarkko Linnanvirta: https://github.com/Taitava/\r\n */\r\n\r\nimport {IParameters} from \"./Variable\";\r\nimport {IAutocompleteItem} from \"../settings/setting_elements/Autocomplete\";\r\nimport {EditorVariable} from \"./EditorVariable\";\r\nimport {Editor} from \"obsidian\";\r\n\r\nexport class Variable_CaretPosition extends EditorVariable {\r\n    public variable_name = \"caret_position\";\r\n    public help_text = \"Gives the line number and column position of the current caret position as 'line:column'. Get only the line number using {{caret_position:line}}, and only the column with {{caret_position:column}}. Line and column numbers are 1-indexed.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        mode: {\r\n            options: [\"line\", \"column\"],\r\n            required: false,\r\n        },\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {mode?: string}): Promise<string> {\r\n        // Check that we are able to get an editor\r\n        const editor: Editor = this.getEditorOrThrow();\r\n\r\n        const position = editor.getCursor('to');\r\n        const line = position.line + 1; // editor position is zero-indexed, line numbers are 1-indexed\r\n        const column = position.ch + 1; // editor position is zero-indexed, column positions are 1-indexed\r\n\r\n        if (undefined !== castedArguments.mode) {\r\n            switch (castedArguments.mode.toLowerCase()) {\r\n                case \"line\":\r\n                    return `${line}`;\r\n                case \"column\":\r\n                    return `${column}`;\r\n                default:\r\n                    this.throw(\"Unrecognised argument: \"+castedArguments.mode);\r\n            }\r\n        } else {\r\n            // default case when no args provided\r\n            return `${line}:${column}`;\r\n        }\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \"}}\",\r\n                help_text: \"Gives the line number and column position of the current caret position as 'line:column'. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":line}}\",\r\n                help_text: \"Gives the line number of the current caret position. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":column}}\",\r\n                help_text: \"Gives the column number of the current caret position. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \"}}\",\r\n                help_text: \"Gives the line number and column position of the current caret position as 'line:column'. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":line}}\",\r\n                help_text: \"Gives the line number of the current caret position. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":column}}\",\r\n                help_text: \"Gives the column number of the current caret position. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{caret_position}}</strong>, <strong>{{caret_position:line}}</strong> or <strong>{{caret_position:column}}</strong>\";\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return super.getAvailabilityText() + \" Not available in preview mode.\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {moment} from \"obsidian\";\r\nimport {IParameters, Variable} from \"./Variable\";\r\n\r\nexport class Variable_Date extends Variable {\r\n    public variable_name = \"date\";\r\n    public help_text = \"Gives a date/time stamp as per your liking. The \\\"format\\\" part can be customized and is mandatory. Formatting options: https://momentjs.com/docs/#/displaying/format/\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        format: {\r\n            type: \"string\",\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {format: string}): Promise<string> {\r\n        return moment().format(castedArguments.format);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {getVaultAbsolutePath, normalizePath2, uniqueArray} from \"../Common\";\r\nimport {App, getAllTags, TFile, TFolder} from \"obsidian\";\r\n\r\n/**\r\n * TODO: Consider creating a decorator class for TFolder and moving this function to be a method in it.\r\n *\r\n * @param app\r\n * @param folder\r\n * @param mode\r\n */\r\nexport function getFolderPath(app: App, folder: TFolder, mode: \"absolute\" | \"relative\") {\r\n    switch (mode.toLowerCase() as \"absolute\" | \"relative\") {\r\n        case \"absolute\":\r\n            return normalizePath2(getVaultAbsolutePath(app) + \"/\" + folder.path);\r\n        case \"relative\":\r\n            if (folder.isRoot()) {\r\n                // Obsidian API does not give a correct folder.path value for the vault's root folder.\r\n                // TODO: See this discussion and apply possible changes if something will come up: https://forum.obsidian.md/t/vault-root-folders-relative-path-gives/24857\r\n                return \".\";\r\n            } else {\r\n                // This is a normal subfolder\r\n                return normalizePath2(folder.path); // Normalize to get a correct slash between directories depending on platform. On Windows it should be \\ .\r\n            }\r\n    }\r\n}\r\n\r\n/**\r\n * TODO: Consider creating a decorator class for TFile and moving this function to be a method in it.\r\n *\r\n * @param app\r\n * @param file\r\n * @param mode\r\n */\r\nexport function getFilePath(app: App, file: TFile, mode: \"absolute\" | \"relative\") {\r\n    switch (mode.toLowerCase() as \"absolute\" | \"relative\") {\r\n        case \"absolute\":\r\n            return normalizePath2(getVaultAbsolutePath(app) + \"/\" + file.path);\r\n        case \"relative\":\r\n            return normalizePath2(file.path); // Normalize to get a correct slash depending on platform. On Windows it should be \\ .\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * TODO: Consider creating a decorator class for TFile and moving this function to be a method in it.\r\n * @param file\r\n * @param with_dot\r\n */\r\nexport function getFileExtension(file: TFile, with_dot: boolean) {\r\n    const file_extension = file.extension;\r\n\r\n    // Should the extension be given with or without a dot?\r\n    if (with_dot) {\r\n        // A preceding dot must be included.\r\n        if (file_extension.length > 0) {\r\n            // But only if the extension is not empty.\r\n            return \".\" + file_extension;\r\n        }\r\n    }\r\n\r\n    // No dot should be included, or the extension is empty\r\n    return file_extension;\r\n}\r\n\r\nexport function getFileTags(app: App, file: TFile) {\r\n    const cache = app.metadataCache.getFileCache(file);\r\n    if (!cache) {\r\n        throw new Error(\"Could not get metadata cache.\");\r\n    }\r\n\r\n    // Get tags. May include duplicates, if a tag is defined multiple times in the same file.\r\n    const tagsIncludingDuplicates: string[] = getAllTags(cache) ?? []; // ?? [] = in case null is returned, convert it to an empty array. I have no clue in which situation this might happen. Maybe if the file does not contain any tags?\r\n\r\n    // Iron out possible duplicates.\r\n    const tagsWithoutDuplicates: string[] = uniqueArray(tagsIncludingDuplicates);\r\n\r\n    // Remove preceding hash characters. E.g. #tag becomes tag\r\n    tagsWithoutDuplicates.forEach((tag: string, index) => {\r\n        tagsWithoutDuplicates[index] = tag.replace(\"#\", \"\");\r\n    });\r\n    return tagsWithoutDuplicates;\r\n}\r\n\r\n/**\r\n * @param app\r\n * @param file\r\n * @param property_path\r\n * @return string|string[] Either a result string, or an array of error messages.\r\n */\r\nexport function getFileYAMLValue(app: App, file: TFile, property_path: string) {\r\n    const error_messages: string[] = [];\r\n    const property_parts = property_path.split(\".\");\r\n\r\n    // Validate all property names along the path\r\n    property_parts.forEach((property_name: string) => {\r\n        if (0 === property_name.length) {\r\n            error_messages.push(\"YAML property '\" + property_path + \"' has an empty property name. Remove possible double dots or a preceding/trailing dot.\");\r\n        }\r\n    });\r\n    if (error_messages.length > 0) {\r\n        // Failure in property name(s).\r\n        return error_messages;\r\n    }\r\n\r\n    const frontmatter = app.metadataCache.getFileCache(file)?.frontmatter;\r\n    // Check that a YAML section is available in the file\r\n    if (undefined === frontmatter) {\r\n        // No it ain't.\r\n        error_messages.push(\"No YAML frontmatter section is defined for the current file.\");\r\n        return error_messages;\r\n    } else {\r\n        // A YAML section is available.\r\n        // Read the property's value.\r\n        return nested_read(property_parts, property_path, frontmatter);\r\n    }\r\n\r\n    /**\r\n     * @param property_parts Property path split into parts (= property names). The deeper the nesting goes, the fewer values will be left in this array. This should always contain at least one part! If not, an Error is thrown.\r\n     * @param property_path The original, whole property path string.\r\n     * @param yaml_object\r\n     * @return string|string[] Either a result string, or an array of error messages.\r\n     */\r\n    function nested_read(property_parts: string[], property_path: string, yaml_object: { [key: string]: string | number | object }): string | string[] {\r\n        // Check that property_parts contains at least one part.\r\n        if (property_parts.length === 0) {\r\n            throw new Error(\"No more property parts to read!\");\r\n        }\r\n        let property_name: string = property_parts.shift() as string; // as string: Tell TypeScript that the result is not undefined, because the array is not empty.\r\n\r\n        // Check if the property name is a negative numeric index.\r\n        if (property_name.match(/^-\\d+$/u)) {\r\n            // The property name is a negative number.\r\n            // Check that yaml_object contains at least one element.\r\n            const yaml_object_keys = Object.getOwnPropertyNames(yaml_object).filter(key => key !== \"length\"); // All _really custom_ yaml keys, not .length\r\n            if (yaml_object_keys.length > 0) {\r\n                // Check if yaml_object happens to be an indexed list.\r\n                let is_indexed_list = true;\r\n                yaml_object_keys.forEach((key) => {\r\n                    if (!key.match(/^\\d+$/u)) {\r\n                        // At least one non-numeric key was found, so consider the object not to be an indexed list.\r\n                        is_indexed_list = false;\r\n                    }\r\n                });\r\n                if (is_indexed_list) {\r\n                    // The object is an indexed list and property_name is a negative index number.\r\n                    // Translate property_name to a positive index from the end of the list.\r\n                    property_name = Math.max(0, // If a greatly negative index is used (e.g. -999), don't allow the new index to be negative again.\r\n                        yaml_object_keys.length\r\n                        + parseInt(property_name) // Although + is used, this will be a subtraction, because property_name is prefixed with a minus.\r\n                    ).toString();\r\n                }\r\n            }\r\n        }\r\n\r\n        // Get a value\r\n        const property_value = yaml_object[property_name];\r\n\r\n        // Check if the value is either: not found, object, or literal.\r\n        if (undefined === property_value) {\r\n            // Property was not found.\r\n            error_messages.push(\"YAML property '\" + property_name + \"' is not found.\");\r\n            return error_messages;\r\n        } else if (null === property_value) {\r\n            // Property is found, but has an empty value. Example:\r\n            //   ---\r\n            //   itemA: valueA\r\n            //   itemB:\r\n            //   itemC: valueC\r\n            //   ---\r\n            // Here `itemB` would have a null value.\r\n            error_messages.push(\"YAML property '\" + property_name + \"' has a null value. Make sure the property is not accidentally left empty.\");\r\n            return error_messages;\r\n        } else if (\"object\" === typeof property_value) {\r\n            // The value is an object.\r\n            // Check if we have still dot notation parts left in the property path.\r\n            if (0 === property_parts.length) {\r\n                // No dot notation parts are left.\r\n                // Freak out.\r\n                const nested_elements_keys = Object.getOwnPropertyNames(property_value);\r\n                if (nested_elements_keys.length > 0) {\r\n                    error_messages.push(\"YAML property '\" + property_name + \"' contains a nested element with keys: \" + nested_elements_keys.join(\", \") + \". Use e.g. '\" + property_path + \".\" + nested_elements_keys[0] + \"' to get its value.\");\r\n                } else {\r\n                    error_messages.push(\"YAML property '\" + property_name + \"' contains a nested element. Use a property name that points to a literal value instead.\");\r\n                }\r\n                return error_messages;\r\n            } else {\r\n                // Dot notation path still has another property name left, so continue the hunt.\r\n                return nested_read(property_parts, property_path, property_value as { [key: string]: string | number | object });\r\n            }\r\n        } else {\r\n            // The value is literal, i.e. a string or number.\r\n            if (property_parts.length > 0) {\r\n                error_messages.push(\"YAML property '\" + property_name + \"' gives already a literal value '\" + property_value.toString() + \"', but the argument '\" + property_path + \"' assumes the property would contain a nested element with the key '\" + property_parts[0] + \"'.\");\r\n                return error_messages;\r\n            } else {\r\n                return property_value.toString();\r\n            }\r\n        }\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Variable} from \"./Variable\";\r\nimport {TFile} from \"obsidian\";\r\n\r\nexport abstract class FileVariable extends Variable {\r\n\r\n    protected always_available = false;\r\n\r\n    protected getFileOrThrow(): TFile | never {\r\n        const currentFile = this.app.workspace.getActiveFile();\r\n        if (!currentFile) {\r\n            this.throw(\"No file is active at the moment. Open a file or click a pane that has a file open.\");\r\n        }\r\n        return currentFile;\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return \"<strong>Only available</strong> when the active pane contains a file, not in graph view or other non-file view.\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {IParameters} from \"./Variable\";\r\nimport {IAutocompleteItem} from \"../settings/setting_elements/Autocomplete\";\r\nimport {getFileExtension} from \"./VariableHelpers\";\r\nimport {FileVariable} from \"./FileVariable\";\r\n\r\nexport class Variable_FileExtension extends FileVariable {\r\n    public variable_name = \"file_extension\";\r\n    public help_text = \"Gives the current file name's ending. Use {{file_extension:with-dot}} to include a preceding dot. If the extension is empty, no dot is added. {{file_extension:no-dot}} never includes a dot.\";\r\n\r\n    protected static parameters: IParameters = {\r\n        \"dot\": {\r\n            options: [\"with-dot\", \"no-dot\"],\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {\"dot\": \"with-dot\" | \"no-dot\"}): Promise<string> {\r\n        return getFileExtension(this.getFileOrThrow(), castedArguments.dot === \"with-dot\");\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":no-dot}}\",\r\n                help_text: \"Gives the current file name's ending without a preceding dot. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":with-dot}}\",\r\n                help_text: \"Gives the current file name's ending with a preceding dot. If the extension is empty, no dot is included. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":no-dot}}\",\r\n                help_text: \"Gives the current file name's ending without a preceding dot. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":with-dot}}\",\r\n                help_text: \"Gives the current file name's ending with a preceding dot. If the extension is empty, no dot is included. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{file_extension:with-dot}}</strong> or <strong>{{file_extension:no-dot}}</strong>\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {FileVariable} from \"./FileVariable\";\r\n\r\nexport class Variable_FileName extends FileVariable {\r\n    public variable_name = \"file_name\";\r\n    public help_text = \"Gives the current file name with a file extension. If you need it without the extension, use {{title}} instead.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        return this.getFileOrThrow().name;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {IParameters} from \"./Variable\";\r\nimport {IAutocompleteItem} from \"../settings/setting_elements/Autocomplete\";\r\nimport {FileVariable} from \"./FileVariable\";\r\nimport {getFilePath} from \"./VariableHelpers\";\r\n\r\nexport class Variable_FilePath extends FileVariable{\r\n    public variable_name = \"file_path\";\r\n    public help_text = \"Gives path to the current file, either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        mode: {\r\n            options: [\"absolute\", \"relative\"],\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {mode: \"absolute\" | \"relative\"}): Promise<string> {\r\n        return getFilePath(this.app, this.getFileOrThrow(), castedArguments.mode);\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"Gives path to the current file, absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":relative}}\",\r\n                help_text: \"Gives path to the current file, relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"Gives path to the current file, absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":relative}}\",\r\n                help_text: \"Gives path to the current file, relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{file_path:relative}}</strong> or <strong>{{file_path:absolute}}</strong>\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {FileVariable} from \"./FileVariable\";\r\nimport {\r\n    TFile,\r\n    TFolder,\r\n} from \"obsidian\";\r\n\r\nexport abstract class FolderVariable extends FileVariable {\r\n\r\n    protected getFolderOrThrow(): TFolder | never {\r\n        // Get current file's parent folder.\r\n        const file: TFile = this.getFileOrThrow();\r\n        const currentFolder: TFolder = file.parent;\r\n        if (!currentFolder) {\r\n            // No parent folder.\r\n            this.throw(\"The current file does not have a parent for some strange reason.\");\r\n        }\r\n        return currentFolder;\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {FolderVariable} from \"./FolderVariable\";\r\n\r\nexport class Variable_FolderName extends FolderVariable {\r\n    public variable_name = \"folder_name\";\r\n    public help_text = \"Gives the current file's parent folder name, or a dot if the folder is the vault's root. No ancestor folders are included.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        const folder = this.getFolderOrThrow();\r\n        return folder.isRoot()\r\n            ? \".\" // Return a dot instead of an empty string.\r\n            : folder.name\r\n        ;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {IParameters} from \"./Variable\";\r\nimport {IAutocompleteItem} from \"../settings/setting_elements/Autocomplete\";\r\nimport {FolderVariable} from \"./FolderVariable\";\r\nimport {getFolderPath} from \"./VariableHelpers\";\r\n\r\nexport class Variable_FolderPath extends FolderVariable {\r\n    public variable_name = \"folder_path\";\r\n    public help_text = \"Gives path to the current file's parent folder, either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        mode: {\r\n            options: [\"absolute\", \"relative\"],\r\n            required: true,\r\n        }\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {mode: \"absolute\" | \"relative\"}): Promise<string> {\r\n        return getFolderPath(this.app, this.getFolderOrThrow(), castedArguments.mode);\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"Gives path to the current file's parent folder, absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":relative}}\",\r\n                help_text: \"Gives path to the current file's parent folder, relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"Gives path to the current file's parent folder, absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":relative}}\",\r\n                help_text: \"Gives path to the current file's parent folder, relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{folder_path:relative}}</strong> or <strong>{{folder_path:absolute}}</strong>\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EditorVariable} from \"./EditorVariable\";\r\nimport {EOL} from \"os\";\r\n\r\nexport class Variable_Selection extends EditorVariable {\r\n    public variable_name = \"selection\";\r\n    public help_text = \"Gives the currently selected text.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n\r\n        // Check that we are able to get an editor\r\n        const editor = this.getEditorOrThrow();\r\n\r\n        // Check the view mode\r\n        this.requireViewModeSource();\r\n\r\n        // Good, the editor is in \"source\" mode, so it's possible to get a selection.\r\n        if (editor.somethingSelected()) {\r\n            return editor.getSelection();\r\n        }\r\n        this.throw(\"Nothing is selected. \"+EOL+EOL+\"(This error message was added in SC 0.18.0. Earlier the variable gave an empty text in this situation. If you want to restore the old behavior, go to SC settings, then to Variables tab, and define a default value for {{selection}}.)\");\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return \"<strong>Only available</strong> when something is selected in <em>Editing</em>/<em>Live preview</em> mode, <strong>not</strong> in <em>Reading</em> mode.\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {IParameters} from \"./Variable\";\r\nimport {FileVariable} from \"./FileVariable\";\r\nimport {getFileTags} from \"./VariableHelpers\";\r\n\r\nexport class Variable_Tags extends FileVariable {\r\n    public variable_name = \"tags\";\r\n    public help_text = \"Gives all tags defined in the current note. Replace the \\\"separator\\\" part with a comma, space or whatever characters you want to use as a separator between tags. A separator is always needed to be defined.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        separator: {\r\n            type: \"string\",\r\n            required: true,\r\n        }\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {separator: string}): Promise<string> {\r\n        return getFileTags(this.app, this.getFileOrThrow()).join(castedArguments.separator);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {FileVariable} from \"./FileVariable\";\r\n\r\nexport class Variable_Title extends FileVariable{\r\n    public variable_name = \"title\";\r\n    public help_text = \"Gives the current file name without a file extension. If you need it with the extension, use {{file_name}} instead.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        return this.getFileOrThrow().basename;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {getVaultAbsolutePath} from \"../Common\";\r\nimport {Variable} from \"./Variable\";\r\n\r\nexport class Variable_VaultPath extends Variable{\r\n    public variable_name = \"vault_path\";\r\n    public help_text = \"Gives the Obsidian vault's absolute path from the root of the filesystem. This is the same that is used as a default working directory if you do not define one manually. If you define a working directory manually, this variable won't give you your manually defined directory, it always gives the vault's root directory.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        return getVaultAbsolutePath(this.app);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Variable} from \"./Variable\";\r\n\r\nexport class Variable_Workspace extends Variable{\r\n    public variable_name = \"workspace\";\r\n    public help_text = \"Gives the current workspace's name.\";\r\n\r\n    protected always_available = false;\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        // Idea how to access the workspaces plugin is copied 2021-09-15 from https://github.com/Vinzent03/obsidian-advanced-uri/blob/f7ef80d5252481242e69496208e925874209f4aa/main.ts#L168-L179\r\n        // @ts-ignore internalPlugins exists, although it's not in obsidian.d.ts.\r\n        const workspaces_plugin = this.app.internalPlugins?.plugins?.workspaces;\r\n        if (!workspaces_plugin) {\r\n            this.throw(\"Workspaces core plugin is not found for some reason. Please create a discussion in GitHub.\");\r\n        } else if (!workspaces_plugin.enabled) {\r\n            this.throw(\"Workspaces core plugin is not enabled.\");\r\n        }\r\n\r\n        const workspace_name = workspaces_plugin.instance?.activeWorkspace;\r\n        if (!workspace_name) {\r\n            this.throw(\"Could not figure out the current workspace's name. Probably you have not loaded a workspace. You can do it e.g. via \\\"Manage workspaces\\\" from the left side panel.\");\r\n        }\r\n\r\n        // All ok\r\n        return workspace_name;\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return \"<strong>Only available</strong> when the Workspaces core plugin is enabled.\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    IParameters,\r\n    Variable,\r\n} from \"./Variable\";\r\n\r\nexport class Variable_Passthrough extends Variable {\r\n    public variable_name = \"passthrough\";\r\n    public help_text = \"Gives the same value that is passed as an argument. Used for testing special characters' escaping.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        value: {\r\n            type: \"string\",\r\n            required: true,\r\n        }\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {value: string}): Promise<string> {\r\n        // Simply return the argument that was received.\r\n        return castedArguments.value;\r\n    }\r\n\r\n    public getAvailabilityText() {\r\n        return \"<strong>Only available</strong> in debug mode.\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {IParameters} from \"./Variable\";\r\nimport {FileVariable} from \"./FileVariable\";\r\nimport {getFileYAMLValue} from \"./VariableHelpers\";\r\n\r\nexport class Variable_YAMLValue extends FileVariable {\r\n    public variable_name = \"yaml_value\";\r\n    public help_text = \"Reads a single value from the current file's frontmatter. Takes a property name as an argument. You can access nested properties with dot notation: property1.property2\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        property_name: {\r\n            type: \"string\",\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {property_name: string}): Promise<string> {\r\n        // We do have an active file\r\n        const result = getFileYAMLValue(this.app, this.getFileOrThrow(), castedArguments.property_name);\r\n        if (Array.isArray(result)) {\r\n            // The result contains error message(s).\r\n            this.throw(result.join(\" \"));\r\n        } else {\r\n            // The result is ok, it's a string.\r\n            return result;\r\n        }\r\n    }\r\n    public getAvailabilityText(): string {\r\n        return super.getAvailabilityText() + \" Also, the given YAML property must exist in the file's frontmatter.\";\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{yaml_value:property}}</strong>\";\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    Variable,\r\n} from \"../Variable\";\r\nimport {SC_Event} from \"../../events/SC_Event\";\r\n\r\nexport abstract class EventVariable extends Variable {\r\n\r\n    protected always_available = false;\r\n\r\n    /**\r\n     * @protected\r\n     * @abstract Should be abstract, but cannot mark is as abstract because it's also static.\r\n     */\r\n    protected supported_sc_events: typeof SC_Event[];\r\n\r\n    /**\r\n     * Every subclass should call this method in their generateValue() before generating a value. This method will throw\r\n     * a VariableError if an incompatible SC_Event is tried to be used with this {{variable}}.\r\n     *\r\n     * @protected\r\n     */\r\n    protected requireCorrectEvent(sc_event: SC_Event): void {\r\n        // 1. Check generally that an event is happening.\r\n        // (Maybe this check is not so important anymore, as sc_event is now received as a parameter instead of from a property, but check just in case.)\r\n        if (!sc_event) {\r\n            this.throw(\"This variable can only be used during events: \" + this.getSummaryOfSupportedEvents());\r\n        }\r\n\r\n        // 2. Check particularly which event it is.\r\n        if (!this.supportsSC_Event(sc_event.getClass())) {\r\n            this.throw(\"This variable does not support event '\" + sc_event.static().getTitle() + \"'. Supported events: \" + this.getSummaryOfSupportedEvents());\r\n        }\r\n    }\r\n\r\n    public supportsSC_Event(sc_event_class: typeof SC_Event): boolean {\r\n        return this.supported_sc_events.contains(sc_event_class);\r\n    }\r\n\r\n    private getSummaryOfSupportedEvents(): string {\r\n        const sc_event_titles: string[] = [];\r\n        this.supported_sc_events.forEach((sc_event_class: typeof SC_Event) => {\r\n            sc_event_titles.push(sc_event_class.getTitle());\r\n        });\r\n        return sc_event_titles.join(\", \");\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return \"<strong>Only available</strong> in events: \" + this.getSummaryOfSupportedEvents() + \".\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../main\";\r\nimport {App, EventRef} from \"obsidian\";\r\nimport {\r\n    ShellCommandParsingProcess,\r\n    TShellCommand,\r\n} from \"../TShellCommand\";\r\nimport {SC_EventConfiguration} from \"./SC_EventConfiguration\";\r\nimport {cloneObject} from \"../Common\";\r\nimport {Variable} from \"../variables/Variable\";\r\nimport {EventVariable} from \"../variables/event_variables/EventVariable\";\r\nimport {DocumentationEventsFolderLink} from \"../Documentation\";\r\nimport {\r\n    ShellCommandExecutor\r\n} from \"../imports\";\r\n\r\n/**\r\n * Named SC_Event instead of just Event, because Event is a class in JavaScript.\r\n */\r\nexport abstract class SC_Event {\r\n    protected readonly plugin: SC_Plugin;\r\n    protected readonly app: App;\r\n\r\n    /**\r\n     * @protected\r\n     * @abstract Should be abstract, but cannot mark is as abstract because it's also static.\r\n     */\r\n    protected static readonly event_code: string;\r\n\r\n    /**\r\n     * @protected\r\n     * @abstract Should be abstract, but cannot mark is as abstract because it's also static.\r\n     */\r\n    protected static readonly event_title: string;\r\n\r\n    /**\r\n     * If true, changing the enabled/disabled status of the event permits registering the event immediately, so it can activate\r\n     * anytime. Usually true, but can be set to false if immediate registering tends to trigger the event unnecessarily.\r\n     *\r\n     * Events are always registered when loading the plugin, regardless of this property.\r\n     * @protected\r\n     */\r\n    protected register_after_changing_settings = true;\r\n\r\n    private event_registrations: {\r\n        [key: string]: EventRef, // key: t_shell_command id\r\n    } = {};\r\n    protected default_configuration: SC_EventConfiguration = {\r\n        enabled: false,\r\n    };\r\n\r\n    public constructor(plugin: SC_Plugin) {\r\n        this.plugin = plugin;\r\n        this.app = plugin.app;\r\n\r\n        this.subclass_instance = this; // Stores a subclass reference, not a base class reference.\r\n    }\r\n\r\n    /**\r\n     * Contains a version of 'this' variable that refers to the actual subclass, not this base class.\r\n     * TODO: Perhaps move to a new class that will become a parent of this class?\r\n     * @private\r\n     */\r\n    private subclass_instance: this;\r\n    public getClass() {\r\n        return this.subclass_instance.constructor as typeof SC_Event;\r\n    }\r\n\r\n    public canRegisterAfterChangingSettings(): boolean {\r\n        return this.register_after_changing_settings;\r\n    }\r\n\r\n    public register(t_shell_command: TShellCommand) {\r\n        const event_reference = this._register(t_shell_command);\r\n        if (event_reference) {\r\n            this.plugin.registerEvent(event_reference);\r\n            this.event_registrations[t_shell_command.getId()] = event_reference;\r\n        }\r\n    }\r\n\r\n    public unregister(t_shell_command: TShellCommand) {\r\n        // Check if an EventRef is available.\r\n        if (undefined === this.event_registrations[t_shell_command.getId()]) {\r\n            // The event was registered without an EventRef object.\r\n            // Provide a TShellCommand to _unregister() so it can do a custom unregistering.\r\n            this._unregister(t_shell_command);\r\n        } else {\r\n            // The event registration had created an EventRef object.\r\n            // Provide the EventRef to _unregister() and forget it afterwards.\r\n            this._unregister(this.event_registrations[t_shell_command.getId()]);\r\n            delete this.event_registrations[t_shell_command.getId()];\r\n        }\r\n    }\r\n\r\n    protected abstract _register(t_shell_command: TShellCommand): false | EventRef;\r\n\r\n    protected abstract _unregister(t_shell_command: TShellCommand): void;\r\n    protected abstract _unregister(event_reference: EventRef): void;\r\n\r\n    /**\r\n     * Executes a shell command.\r\n     * @param t_shell_command\r\n     * @param parsing_process SC_MenuEvent can use this to pass an already started ParsingProcess instance. If omitted, a new ParsingProcess will be created.\r\n     */\r\n    protected async trigger(t_shell_command: TShellCommand, parsing_process?: ShellCommandParsingProcess) {\r\n        // Execute the shell command.\r\n        const executor = new ShellCommandExecutor(this.plugin, t_shell_command, this);\r\n        await executor.doPreactionsAndExecuteShellCommand(parsing_process);\r\n    }\r\n\r\n    public static getCode() {\r\n        return this.event_code;\r\n    }\r\n\r\n    public static getTitle() {\r\n        return this.event_title;\r\n    }\r\n\r\n    /**\r\n     * Creates a list of variables to the given container element. Each variable is a link to its documentation.\r\n     *\r\n     * @param container\r\n     * @return A boolean indicating whether anything was created or not. Not all SC_Events utilise event variables.\r\n     */\r\n    public createSummaryOfEventVariables(container: HTMLElement): boolean {\r\n        let hasCreatedElements = false;\r\n        this.getEventVariables().forEach((variable: Variable) => {\r\n            if (hasCreatedElements) {\r\n                container.insertAdjacentText(\"beforeend\", \", \");\r\n            }\r\n            hasCreatedElements = true;\r\n            variable.createDocumentationLinkElement(container);\r\n        });\r\n        return hasCreatedElements;\r\n    }\r\n\r\n    private getEventVariables() {\r\n        const event_variables: EventVariable[] = [];\r\n        this.plugin.getVariables().forEach((variable: Variable) => {\r\n            // Check if the variable is an EventVariable\r\n            if (variable instanceof EventVariable) {\r\n                // Yes it is.\r\n                // Check if the variable supports this particular event.\r\n                if (variable.supportsSC_Event(this.getClass())) {\r\n                    // Yes it supports.\r\n                    event_variables.push(variable);\r\n                }\r\n            }\r\n        });\r\n        return event_variables;\r\n    }\r\n\r\n    /**\r\n     * Can be overridden in child classes that need custom settings fields.\r\n     *\r\n     * @param enabled\r\n     */\r\n    public getDefaultConfiguration(enabled: boolean): SC_EventConfiguration {\r\n        const configuration = cloneObject<SC_EventConfiguration>(this.default_configuration);\r\n        configuration.enabled = enabled;\r\n        return configuration;\r\n    }\r\n\r\n    protected getConfiguration(t_shell_command: TShellCommand) {\r\n        return t_shell_command.getEventConfiguration(this);\r\n    }\r\n\r\n    /**\r\n     * Can be overridden in child classes to provide custom configuration fields for ShellCommandsExtraOptionsModal.\r\n     *\r\n     * @param extra_settings_container\r\n     */\r\n    public createExtraSettingsFields(extra_settings_container: HTMLDivElement, t_shell_command: TShellCommand): void {\r\n        // Most classes do not define custom settings, so for those classes this method does not need to do anything.\r\n    }\r\n\r\n    /**\r\n     * Returns all the TShellCommand instances that have enabled this event.\r\n     */\r\n    public getTShellCommands(): TShellCommand[] {\r\n        const enabled_t_shell_commands: TShellCommand[] = [];\r\n        Object.values(this.plugin.getTShellCommands()).forEach((t_shell_command: TShellCommand) => {\r\n            // Check if this event has been enabled for the shell command.\r\n            if (t_shell_command.isSC_EventEnabled(this.static().event_code)) {\r\n                // Yes, it's enabled.\r\n                enabled_t_shell_commands.push(t_shell_command);\r\n            }\r\n        });\r\n        return enabled_t_shell_commands;\r\n    }\r\n\r\n    public static() {\r\n        return this.constructor as typeof SC_Event;\r\n    }\r\n\r\n    /**\r\n     * Child classes can override this to hook into a situation where a user has enabled an event in settings.\r\n     *\r\n     * @param t_shell_command The TShellCommand instance for which this SC_Event was enabled for.\r\n     */\r\n    public onAfterEnabling(t_shell_command: TShellCommand): void {\r\n        // If an SC_Event does not override this hook method, do nothing.\r\n    }\r\n\r\n    public static getDocumentationLink(): string {\r\n        return DocumentationEventsFolderLink + encodeURIComponent(this.event_title);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Event} from \"./SC_Event\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {EventRef} from \"obsidian\";\r\n\r\nexport abstract class SC_WorkspaceEvent extends SC_Event {\r\n    protected abstract readonly workspace_event:\r\n        // TODO: Find a way to make this list dynamic.\r\n        // This list reflects Obsidian API version 0.12.11.\r\n        | 'quick-preview'\r\n        | 'resize'\r\n        | 'click'\r\n        | 'active-leaf-change'\r\n        | 'file-open'\r\n        | 'layout-change'\r\n        | 'css-change'\r\n        | 'file-menu'\r\n        | 'editor-menu'\r\n        | 'codemirror'\r\n        | 'quit'\r\n    ;\r\n\r\n    protected _register(t_shell_command: TShellCommand) {\r\n        // @ts-ignore TODO: Find a way to get a dynamic type for this.workspace_event .\r\n        return this.app.workspace.on(this.workspace_event, this.getTrigger(t_shell_command));\r\n    }\r\n\r\n    protected _unregister(event_reference: EventRef): void {\r\n        this.app.workspace.offref(event_reference);\r\n    }\r\n\r\n    protected getTrigger(t_shell_command: TShellCommand) {\r\n        return async (...parameters: unknown[] /* Need to have this ugly parameter thing so that subclasses can define their own parameters. */) => await this.trigger(t_shell_command);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_WorkspaceEvent} from \"./SC_WorkspaceEvent\";\r\nimport {ShellCommandParsingProcess, TShellCommand} from \"../TShellCommand\";\r\nimport {Menu} from \"obsidian\";\r\nimport {ParsingResult} from \"../variables/parseVariables\";\r\n\r\nexport abstract class SC_MenuEvent extends SC_WorkspaceEvent {\r\n\r\n    protected async addTShellCommandToMenu(t_shell_command: TShellCommand, menu: Menu) {\r\n        // Create the menu item as soon as possible. (If it's created after 'await parsing_process.process()' below, it won't be shown in the menu for some reason, at least in Obsidian 0.16.1).\r\n        menu.addItem(async menuItem => {\r\n            // Parse shell command variables to get a title\r\n            let title = t_shell_command.getAliasOrShellCommand(); // May contain unparsed variables.\r\n            let parsing_process: ShellCommandParsingProcess;\r\n            if (this.plugin.settings.preview_variables_in_command_palette) {\r\n                // Start a parsing process\r\n                parsing_process = t_shell_command.createParsingProcess(this);\r\n                if (await parsing_process.process()) {\r\n                    // Parsing succeeded.\r\n                    const parsing_results = parsing_process.getParsingResults();\r\n                    const aliasParsingResult: ParsingResult = parsing_results[\"alias\"] as ParsingResult; // as ParsingResult: Tells TypeScript that the object exists.\r\n                    const shellCommandParsingResult: ParsingResult = parsing_results[\"shell_command\"] as ParsingResult; // as ParsingResult: Tells TypeScript that the object exists.\r\n                    title = aliasParsingResult.parsed_content || shellCommandParsingResult.parsed_content as string; // Try to use a parsed alias, but if no alias is available, use a parsed shell command instead. as string = parsed shell command always exist when the parsing itself has succeeded.\r\n                }\r\n                // If parsing process fails, the failed process can be passed to this.trigger(). The execution will eventually be cancelled and error messages displayed (if displaying is allowed).\r\n            }\r\n\r\n            // Set menu item title - be it parsed or not.\r\n            menuItem.setTitle(title);\r\n\r\n            // Icon and onClick handler.\r\n            menuItem\r\n                .setIcon(t_shell_command.getIconId()) // Icon id can be null.\r\n                .onClick(async () => {\r\n                    await this.trigger(\r\n                        t_shell_command,\r\n                        parsing_process,\r\n                    );\r\n                })\r\n            ;\r\n        });\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {Menu, TAbstractFile, TFile, TFolder, WorkspaceLeaf} from \"obsidian\";\r\nimport {SC_MenuEvent} from \"./SC_MenuEvent\";\r\n\r\nexport abstract class SC_AbstractFileMenuEvent extends SC_MenuEvent {\r\n    protected abstract file_or_folder: \"file\" | \"folder\";\r\n    protected readonly workspace_event = \"file-menu\";\r\n    protected file: TFile;\r\n    protected folder: TFolder;\r\n\r\n    protected getTrigger(t_shell_command: TShellCommand) {\r\n        return async (menu: Menu, file: TAbstractFile, source: string, leaf?: WorkspaceLeaf) => {\r\n            // Check that it's the correct menu: if the SC_Event requires a file menu, 'file' needs to be a TFile, otherwise it needs to be a TFolder.\r\n            if ((this.file_or_folder === \"folder\" && file instanceof TFolder) || (this.file_or_folder === \"file\" && file instanceof TFile)) {\r\n                // The menu is correct.\r\n\r\n                // File/folder for declareExtraVariables()\r\n                switch (this.file_or_folder) {\r\n                    case \"file\":\r\n                        this.file = file as TFile;\r\n                        break;\r\n                    case \"folder\":\r\n                        this.folder = file as TFolder;\r\n                        break;\r\n                }\r\n\r\n                await this.addTShellCommandToMenu(t_shell_command, menu);\r\n            }\r\n        };\r\n    }\r\n}\r\n","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_AbstractFileMenuEvent} from \"./SC_AbstractFileMenuEvent\";\r\nimport {TFile, TFolder} from \"obsidian\";\r\n\r\nexport class SC_Event_FileMenu extends SC_AbstractFileMenuEvent {\r\n    protected static readonly event_code = \"file-menu\";\r\n    protected static readonly event_title = \"File menu\";\r\n    protected file_or_folder: \"file\" = \"file\";\r\n\r\n    public getFile(): TFile {\r\n        return this.file;\r\n    }\r\n\r\n    public getFolder(): TFolder {\r\n        return this.file.parent;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Event} from \"./SC_Event\";\r\nimport {\r\n    EventRef,\r\n    TAbstractFile,\r\n    TFile,\r\n    TFolder,\r\n} from \"obsidian\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\n\r\nexport abstract class SC_VaultEvent extends SC_Event {\r\n    protected abstract readonly vault_event:\r\n        // TODO: Find a way to make this list dynamic.\r\n        // This list reflects Obsidian API version 0.12.11.\r\n        | \"create\"\r\n        | \"modify\"\r\n        | \"delete\"\r\n        | \"rename\"\r\n        | \"closed\" // Not implement by any SC_Event_* class, because I'm not sure if this event is needed. But can be implemented if need be.\r\n    ;\r\n    protected abstract file_or_folder: \"file\" | \"folder\";\r\n    protected file: TFile;\r\n    protected folder: TFolder;\r\n\r\n    protected _register(t_shell_command: TShellCommand): false | EventRef {\r\n        // @ts-ignore TODO: Find a way to get a dynamic type for this.vault_event .\r\n        return this.app.vault.on(this.vault_event, this.getTrigger(t_shell_command));\r\n    }\r\n\r\n    protected _unregister(event_reference: EventRef): void {\r\n        this.app.vault.offref(event_reference);\r\n    }\r\n\r\n    protected getTrigger(t_shell_command: TShellCommand) {\r\n        return async (file: TAbstractFile, ...extra_arguments: unknown[] /* Needed for SC_Event_FileRenamed and SC_Event_FolderRenamed to be able to define an additional parameter.*/) => {\r\n\r\n            // Check that it's the correct type of file: if the SC_Event requires a file, 'file' needs to be a TFile, otherwise it needs to be a TFolder.\r\n            if ((this.file_or_folder === \"folder\" && file instanceof TFolder) || (this.file_or_folder === \"file\" && file instanceof TFile)) {\r\n                // The file type is correct.\r\n\r\n                // File/folder for declareExtraVariables()\r\n                switch (this.file_or_folder) {\r\n                    case \"file\":\r\n                        this.file = file as TFile;\r\n                        break;\r\n                    case \"folder\":\r\n                        this.folder = file as TFolder;\r\n                        break;\r\n                }\r\n\r\n                await this.trigger(t_shell_command);\r\n            }\r\n        };\r\n    }\r\n\r\n    /**\r\n     * This should only be called if file_or_folder is \"file\"!\r\n     */\r\n    public getFile(): TFile {\r\n        return this.file;\r\n    }\r\n\r\n    /**\r\n     * This can be called whether file_or_folder is \"file\" or \"folder\".\r\n     */\r\n    public getFolder(): TFolder {\r\n        switch (this.file_or_folder) {\r\n            case \"file\":\r\n                return this.file.parent;\r\n            case \"folder\":\r\n                return this.folder;\r\n        }\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_VaultEvent} from \"./SC_VaultEvent\";\r\n\r\nexport class SC_Event_FileCreated extends SC_VaultEvent {\r\n    protected static readonly event_code = \"file-created\";\r\n    protected static readonly event_title = \"File created\";\r\n    protected readonly vault_event = \"create\";\r\n    protected file_or_folder: \"file\" = \"file\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_VaultEvent} from \"./SC_VaultEvent\";\r\n\r\nexport class SC_Event_FileContentModified extends SC_VaultEvent {\r\n    protected static readonly event_code = \"file-content-modified\";\r\n    protected static readonly event_title = \"File content modified\";\r\n    protected readonly vault_event = \"modify\";\r\n    protected file_or_folder: \"file\" = \"file\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_VaultEvent} from \"./SC_VaultEvent\";\r\n\r\nexport class SC_Event_FileDeleted extends SC_VaultEvent {\r\n    protected static readonly event_code = \"file-deleted\";\r\n    protected static readonly event_title = \"File deleted\";\r\n    protected readonly vault_event = \"delete\";\r\n    protected file_or_folder: \"file\" = \"file\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_VaultEvent} from \"./SC_VaultEvent\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {TAbstractFile} from \"obsidian\";\r\nimport {\r\n    extractFileName,\r\n    extractFileParentPath,\r\n} from \"../Common\";\r\n\r\nexport abstract class SC_VaultMoveOrRenameEvent extends SC_VaultEvent {\r\n    protected readonly vault_event = \"rename\";\r\n\r\n    /**\r\n     * Tells whether this event should trigger when a file/folder is moved OR renamed.\r\n     * @protected\r\n     */\r\n    protected abstract move_or_rename: \"move\" | \"rename\";\r\n\r\n    /**\r\n     * The file's old path, gotten from Obsidian's Vault.on(\"rename\"). Only present if this.file_or_folder is \"file\".\r\n     * @private\r\n     */\r\n    private file_old_relative_path: string;\r\n\r\n    /**\r\n     * If this.file_or_folder is \"file\": The file's parent folder's old path.\r\n     * If this.file_or_folder is \"folder\": The folder's old path.\r\n     *\r\n     * Relative from the vault's root folder. Gotten from Obsidian's Vault.on(\"rename\").\r\n     * @private\r\n     */\r\n    private folder_old_relative_path: string;\r\n\r\n    protected getTrigger(t_shell_command: TShellCommand) {\r\n\r\n        // Get a trigger from the parent class (SC_VaultEvent).\r\n        const trigger = super.getTrigger(t_shell_command);\r\n\r\n        return async (abstract_file: TAbstractFile, old_relative_path: string) => {\r\n\r\n            // Detect if the file/folder was moved or renamed.\r\n            // If the file/folder name has stayed the same, conclude that the file has been MOVED, not renamed. Otherwise, conclude the opposite.\r\n            const old_file_name = extractFileName(old_relative_path);\r\n            const new_file_name = abstract_file.name;\r\n            const event_type = (old_file_name === new_file_name) ? \"move\" : \"rename\"; // Tells what really happened. this.move_or_rename tells what is the condition for the event to trigger.\r\n\r\n            // Only proceed the triggering, if the determined type equals the one defined by the event class.\r\n            if (event_type === this.move_or_rename) {\r\n                // The event type is correct.\r\n\r\n                // File and folder for declareExtraVariables()\r\n                switch (this.file_or_folder) {\r\n                    case \"file\":\r\n                        this.file_old_relative_path = old_relative_path;\r\n                        this.folder_old_relative_path = extractFileParentPath(old_relative_path);\r\n                        break;\r\n                    case \"folder\":\r\n                        this.folder_old_relative_path = old_relative_path;\r\n                        break;\r\n                }\r\n\r\n                // Call the normal trigger function.\r\n                await trigger(abstract_file);\r\n            }\r\n        };\r\n    }\r\n\r\n    public getFolderOldRelativePath() {\r\n        return this.folder_old_relative_path;\r\n    }\r\n\r\n    public getFileOldRelativePath() {\r\n        return this.file_old_relative_path;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_VaultMoveOrRenameEvent} from \"./SC_VaultMoveOrRenameEvent\";\r\n\r\nexport class SC_Event_FileRenamed extends SC_VaultMoveOrRenameEvent {\r\n    protected static readonly event_code = \"file-renamed\";\r\n    protected static readonly event_title = \"File renamed\";\r\n    protected move_or_rename: \"rename\" = \"rename\";\r\n    protected file_or_folder: \"file\" = \"file\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_VaultMoveOrRenameEvent} from \"./SC_VaultMoveOrRenameEvent\";\r\n\r\nexport class SC_Event_FileMoved extends SC_VaultMoveOrRenameEvent {\r\n    protected static readonly event_code = \"file-moved\";\r\n    protected static readonly event_title = \"File moved\";\r\n    protected move_or_rename: \"move\" = \"move\";\r\n    protected file_or_folder: \"file\" = \"file\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\n\r\nexport class Variable_EventFileName extends EventVariable {\r\n    public variable_name = \"event_file_name\";\r\n    public help_text = \"Gives the event related file name with a file extension. If you need it without the extension, use {{event_title}} instead.\";\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        argumentsAreNotUsed: never,\r\n        sc_event: SC_Event_FileMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        return sc_event.getFile().name;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {getFilePath} from \"../VariableHelpers\";\r\nimport {IParameters} from \"../Variable\";\r\nimport {IAutocompleteItem} from \"../../settings/setting_elements/Autocomplete\";\r\n\r\nexport class Variable_EventFilePath extends EventVariable {\r\n    public variable_name = \"event_file_path\";\r\n    public help_text = \"Gives path to the event related file, either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        mode: {\r\n            options: [\"absolute\", \"relative\"],\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        castedArguments: {mode: \"absolute\" | \"relative\"},\r\n        sc_event: SC_Event_FileMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        return getFilePath(this.app, sc_event.getFile(), castedArguments.mode);\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"Gives path to the event related file, absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":relative}}\",\r\n                help_text: \"Gives path to the event related file, relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"Gives path to the event related file, absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":relative}}\",\r\n                help_text: \"Gives path to the event related file, relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{event_file_path:relative}}</strong> or <strong>{{event_file_path:absolute}}</strong>\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_AbstractFileMenuEvent} from \"./SC_AbstractFileMenuEvent\";\r\n\r\nexport class SC_Event_FolderMenu extends SC_AbstractFileMenuEvent {\r\n    protected static readonly event_code = \"folder-menu\";\r\n    protected static readonly event_title = \"Folder menu\";\r\n    protected file_or_folder: \"folder\" = \"folder\";\r\n\r\n    public getFolder() {\r\n        return this.folder;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_VaultEvent} from \"./SC_VaultEvent\";\r\n\r\nexport class SC_Event_FolderCreated extends SC_VaultEvent {\r\n    protected static readonly event_code = \"folder-created\";\r\n    protected static readonly event_title = \"Folder created\";\r\n    protected readonly vault_event = \"create\";\r\n    protected file_or_folder: \"folder\" = \"folder\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_VaultEvent} from \"./SC_VaultEvent\";\r\n\r\nexport class SC_Event_FolderDeleted extends SC_VaultEvent {\r\n    protected static readonly event_code = \"folder-deleted\";\r\n    protected static readonly event_title = \"Folder deleted\";\r\n    protected readonly vault_event = \"delete\";\r\n    protected file_or_folder: \"folder\" = \"folder\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_VaultMoveOrRenameEvent} from \"./SC_VaultMoveOrRenameEvent\";\r\n\r\nexport class SC_Event_FolderRenamed extends SC_VaultMoveOrRenameEvent {\r\n    protected static readonly event_code = \"folder-renamed\";\r\n    protected static readonly event_title = \"Folder renamed\";\r\n    protected move_or_rename: \"rename\" = \"rename\";\r\n    protected file_or_folder: \"folder\" = \"folder\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_VaultMoveOrRenameEvent} from \"./SC_VaultMoveOrRenameEvent\";\r\n\r\nexport class SC_Event_FolderMoved extends SC_VaultMoveOrRenameEvent {\r\n    protected static readonly event_code = \"folder-moved\";\r\n    protected static readonly event_title = \"Folder moved\";\r\n    protected move_or_rename: \"move\" = \"move\";\r\n    protected file_or_folder: \"folder\" = \"folder\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FolderMenu} from \"../../events/SC_Event_FolderMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FolderCreated} from \"../../events/SC_Event_FolderCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FolderDeleted} from \"../../events/SC_Event_FolderDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FolderRenamed} from \"../../events/SC_Event_FolderRenamed\";\r\nimport {SC_Event_FolderMoved} from \"../../events/SC_Event_FolderMoved\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {EventVariable} from \"./EventVariable\";\r\n\r\nexport class Variable_EventFolderName extends EventVariable {\r\n    public variable_name = \"event_folder_name\";\r\n    public help_text = \"File events: Gives the event related file's parent folder name. Folder events: Gives the selected folder's name. Gives a dot if the folder is the vault's root. No ancestor folders are included.\";\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FolderMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n        SC_Event_FolderCreated,\r\n        SC_Event_FolderDeleted,\r\n        SC_Event_FolderMoved,\r\n        SC_Event_FolderRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        argumentsAreNotUsed: never,\r\n        sc_event: SC_Event_FileMenu | SC_Event_FolderMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed | SC_Event_FolderCreated | SC_Event_FolderDeleted | SC_Event_FolderMoved | SC_Event_FolderRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        const folder = sc_event.getFolder();\r\n        return folder.isRoot()\r\n                ? \".\" // Return a dot instead of an empty string.\r\n                : folder.name\r\n        ;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FolderMenu} from \"../../events/SC_Event_FolderMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FolderCreated} from \"../../events/SC_Event_FolderCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FolderDeleted} from \"../../events/SC_Event_FolderDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FolderRenamed} from \"../../events/SC_Event_FolderRenamed\";\r\nimport {SC_Event_FolderMoved} from \"../../events/SC_Event_FolderMoved\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {getFolderPath} from \"../VariableHelpers\";\r\nimport {IParameters} from \"../Variable\";\r\nimport {IAutocompleteItem} from \"../../settings/setting_elements/Autocomplete\";\r\n\r\nexport class Variable_EventFolderPath extends EventVariable {\r\n    public variable_name = \"event_folder_path\";\r\n    public help_text = \"File events: Gives path to the event related file's parent folder. Folder events: Gives path to the event related folder. The path is either absolute from the root of the file system, or relative from the root of the Obsidian vault.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        mode: {\r\n            options: [\"absolute\", \"relative\"],\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FolderMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n        SC_Event_FolderCreated,\r\n        SC_Event_FolderDeleted,\r\n        SC_Event_FolderMoved,\r\n        SC_Event_FolderRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        castedArguments: {mode: \"absolute\" | \"relative\"},\r\n        sc_event: SC_Event_FileMenu | SC_Event_FolderMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed | SC_Event_FolderCreated | SC_Event_FolderDeleted | SC_Event_FolderMoved | SC_Event_FolderRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        return getFolderPath(this.app, sc_event.getFolder(), castedArguments.mode);\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"File events: Gives path to the event related file's parent folder. Folder events: Gives path to the event related folder. The path is absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":relative}}\",\r\n                help_text: \"File events: Gives path to the event related file's parent folder. Folder events: Gives path to the event related folder. The path is relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"File events: Gives path to the event related file's parent folder. Folder events: Gives path to the event related folder. The path is absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":relative}}\",\r\n                help_text: \"File events: Gives path to the event related file's parent folder. Folder events: Gives path to the event related folder. The path is relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{event_folder_path:relative}}</strong> or <strong>{{event_folder_path:absolute}}</strong>\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {EventVariable} from \"./EventVariable\";\r\n\r\nexport class Variable_EventTitle extends EventVariable {\r\n    public variable_name = \"event_title\";\r\n    public help_text = \"Gives the event related file name without a file extension. If you need it with the extension, use {{event_file_name}} instead.\";\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        argumentsAreNotUsed: never,\r\n        sc_event: SC_Event_FileMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        return sc_event.getFile().basename;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {getFileExtension} from \"../VariableHelpers\";\r\nimport {IParameters} from \"../Variable\";\r\nimport {IAutocompleteItem} from \"../../settings/setting_elements/Autocomplete\";\r\n\r\nexport class Variable_EventFileExtension extends EventVariable {\r\n    public variable_name = \"event_file_extension\";\r\n    public help_text = \"Gives the event related file name's ending. Use {{event_file_extension:with-dot}} to include a preceding dot. If the extension is empty, no dot is added. {{event_file_extension:no-dot}} never includes a dot.\";\r\n\r\n    protected static parameters: IParameters = {\r\n        \"dot\": {\r\n            options: [\"with-dot\", \"no-dot\"],\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        castedArguments: {\"dot\": \"with-dot\" | \"no-dot\"},\r\n        sc_event: SC_Event_FileMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        return getFileExtension(sc_event.getFile(), castedArguments.dot === \"with-dot\");\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":no-dot}}\",\r\n                help_text: \"Gives the event related file name's ending without a preceding dot. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":with-dot}}\",\r\n                help_text: \"Gives the event related file name's ending with a preceding dot. If the extension is empty, no dot is included. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":no-dot}}\",\r\n                help_text: \"Gives the event related file name's ending without a preceding dot. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":with-dot}}\",\r\n                help_text: \"Gives the event related file name's ending with a preceding dot. If the extension is empty, no dot is included. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{event_file_extension:with-dot}}</strong> or <strong>{{event_file_extension:no-dot}}</strong>\";\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {IParameters} from \"../Variable\";\r\nimport {getFileTags} from \"../VariableHelpers\";\r\n\r\nexport class Variable_EventTags extends EventVariable {\r\n    public variable_name = \"event_tags\";\r\n    public help_text = \"Gives all tags defined in the event related note. Replace the \\\"separator\\\" part with a comma, space or whatever characters you want to use as a separator between tags. A separator is always needed to be defined.\";\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        separator: {\r\n            type: \"string\",\r\n            required: true,\r\n        }\r\n    };\r\n\r\n    protected async generateValue(\r\n        castedArguments: {separator: string},\r\n        sc_event: SC_Event_FileMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        const file = sc_event.getFile();\r\n        return getFileTags(this.app, file).join(castedArguments.separator);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {getFileYAMLValue} from \"../VariableHelpers\";\r\nimport {IParameters} from \"../Variable\";\r\n\r\nexport class Variable_EventYAMLValue extends EventVariable {\r\n    public variable_name = \"event_yaml_value\";\r\n    public help_text = \"Reads a single value from the event related file's frontmatter. Takes a property name as an argument. You can access nested properties with dot notation: property1.property2\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        property_name: {\r\n            type: \"string\",\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        castedArguments: {property_name: string},\r\n        sc_event: SC_Event_FileMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        const result = getFileYAMLValue(this.app, sc_event.getFile(), castedArguments.property_name);\r\n        if (Array.isArray(result)) {\r\n            // The result contains error message(s).\r\n            this.throw(result.join(\" \"));\r\n        } else {\r\n            // The result is ok, it's a string.\r\n            return result;\r\n        }\r\n    }\r\n    public getAvailabilityText(): string {\r\n        return super.getAvailabilityText() + \" Also, the given YAML property must exist in the file's frontmatter.\";\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{event_yaml_value:property}}</strong>\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {IParameters, Variable} from \"./Variable\";\r\n\r\nexport class Variable_Environment extends Variable {\r\n    public variable_name = \"environment\";\r\n    public help_text = \"Gives an environment variable's value. It's an original value received when Obsidian was started.\";\r\n\r\n    protected always_available = false;\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        variable: {\r\n            type: \"string\",\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {variable: string}): Promise<string> {\r\n        // Check that the requested environment variable exists.\r\n        if (undefined !== process.env[castedArguments.variable]) {\r\n            // Yes, it exists.\r\n            return process.env[castedArguments.variable] as string; // as string: tells TypeScript compiler that the item exists, is not undefined.\r\n        } else {\r\n            // It does not exist.\r\n            // Freak out.\r\n            this.throw(`Environment variable named '${castedArguments.variable}' does not exist.`);\r\n        }\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{environment:variable}}</strong>\";\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return \"<strong>Only available</strong> if the passed environment variable name exists.\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {extractFileName} from \"../../Common\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\n\r\nexport class Variable_EventOldFileName extends EventVariable {\r\n    public variable_name = \"event_old_file_name\";\r\n    public help_text = \"Gives the renamed file's old name with a file extension. If you need it without the extension, use {{event_old_title}} instead.\";\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        argumentsAreNotUsed: never,\r\n        sc_event: SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        return extractFileName(sc_event.getFileOldRelativePath(), true);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {\r\n    getVaultAbsolutePath,\r\n    normalizePath2,\r\n} from \"../../Common\";\r\nimport {IParameters} from \"../Variable\";\r\nimport {IAutocompleteItem} from \"../../settings/setting_elements/Autocomplete\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\n\r\nexport class Variable_EventOldFilePath extends EventVariable {\r\n    public variable_name = \"event_old_file_path\";\r\n    public help_text = \"Gives the renamed/moved file's old path, either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        mode: {\r\n            options: [\"absolute\", \"relative\"],\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        castedArguments: {mode: \"absolute\" | \"relative\"},\r\n        sc_event: SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        const file_old_relative_path = sc_event.getFileOldRelativePath();\r\n        switch (castedArguments.mode.toLowerCase()) {\r\n            case \"relative\":\r\n                return normalizePath2(file_old_relative_path);\r\n            case \"absolute\":\r\n                return normalizePath2(getVaultAbsolutePath(this.app) + \"/\" + file_old_relative_path);\r\n        }\r\n\r\n        this.throw(\"Unrecognized mode parameter: \" + castedArguments.mode);\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"Gives the renamed/moved file's old path, absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":relative}}\",\r\n                help_text: \"Gives the renamed/moved file's old path, relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"Gives the renamed/moved file's old path, absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":relative}}\",\r\n                help_text: \"Gives the renamed/moved file's old path, relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{event_file_path:relative}}</strong> or <strong>{{event_file_path:absolute}}</strong>\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {extractFileName} from \"../../Common\";\r\nimport {SC_Event_FolderRenamed} from \"../../events/SC_Event_FolderRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\n\r\nexport class Variable_EventOldFolderName extends EventVariable {\r\n    public variable_name = \"event_old_folder_name\";\r\n    public help_text = \"File events: Gives the moved file's old parent folder's name. Folder events: Gives the renamed folder's old name.\";\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMoved,\r\n        SC_Event_FolderRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        argumentsAreNotUsed: never,\r\n        sc_event: SC_Event_FileMoved | SC_Event_FolderRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        return extractFileName(sc_event.getFolderOldRelativePath());\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {\r\n    getVaultAbsolutePath,\r\n    normalizePath2,\r\n} from \"../../Common\";\r\nimport {IParameters} from \"../Variable\";\r\nimport {IAutocompleteItem} from \"../../settings/setting_elements/Autocomplete\";\r\nimport {SC_Event_FolderRenamed} from \"../../events/SC_Event_FolderRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {SC_Event_FolderMoved} from \"../../events/SC_Event_FolderMoved\";\r\n\r\nexport class Variable_EventOldFolderPath extends EventVariable {\r\n    public variable_name = \"event_old_folder_path\";\r\n    public help_text = \"File events: Gives the moved file's old parent folder's path. Folder events: Gives the renamed/moved folder's old path. The path is either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        mode: {\r\n            options: [\"absolute\", \"relative\"],\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMoved,\r\n        SC_Event_FolderMoved,\r\n        SC_Event_FolderRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        castedArguments: {mode: \"absolute\" | \"relative\"},\r\n        sc_event: SC_Event_FileMoved | SC_Event_FolderRenamed | SC_Event_FolderMoved,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        const folder_old_relative_path = sc_event.getFolderOldRelativePath();\r\n        switch (castedArguments.mode.toLowerCase()) {\r\n            case \"relative\":\r\n                return normalizePath2(folder_old_relative_path);\r\n            case \"absolute\":\r\n                return normalizePath2(getVaultAbsolutePath(this.app) + \"/\" + folder_old_relative_path);\r\n        }\r\n\r\n        this.throw(\"Unrecognized mode parameter: \" + castedArguments.mode);\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"File events: Gives the moved file's old parent folder's path. Folder events: Gives the renamed/moved folder's old path. The path is absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":relative}}\",\r\n                help_text: \"File events: Gives the moved file's old parent folder's path. Folder events: Gives the renamed/moved folder's old path. The path is relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"File events: Gives the moved file's old parent folder's path. Folder events: Gives the renamed/moved folder's old path. The path is absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":relative}}\",\r\n                help_text: \"File events: Gives the moved file's old parent folder's path. Folder events: Gives the renamed/moved folder's old path. The path is relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{event_file_path:relative}}</strong> or <strong>{{event_file_path:absolute}}</strong>\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {extractFileName} from \"../../Common\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\n\r\nexport class Variable_EventOldTitle extends EventVariable {\r\n    public variable_name = \"event_old_title\";\r\n    public help_text = \"Gives the renamed file's old name without a file extension. If you need it with the extension, use {{event_old_file_name}} instead.\";\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        argumentsAreNotUsed: never,\r\n        sc_event: SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        return extractFileName(sc_event.getFileOldRelativePath(), false);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Variable} from \"./Variable\";\r\n\r\nexport class Variable_NewNoteFolderName extends Variable {\r\n    public variable_name = \"new_note_folder_name\";\r\n    public help_text = \"Gives the folder name for \\\"Default location for new notes\\\" (a setting in Obsidian). No ancestor folders are included.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        const current_file = this.app.workspace.getActiveFile(); // Needed just in case new notes should be created in the same folder as the currently open file.\r\n        const folder = this.app.fileManager.getNewFileParent(current_file ? current_file.path : \"\"); // If no file is open, use an empty string as instructed in .getNewFileParent()'s documentation.\r\n        if (!folder) {\r\n            this.throw(\"Cannot determine a folder name for new notes. Please create a discussion in GitHub.\"); // I guess this never happens.\r\n        }\r\n\r\n        // If the folder is the vault's root folder, return \".\" instead of \" \" (a space character). I don't know why the name is \" \" when the folder is root.\r\n        return folder.isRoot()\r\n            ? \".\"\r\n            : folder.name\r\n        ;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    IParameters,\r\n    Variable,\r\n} from \"./Variable\";\r\nimport {IAutocompleteItem} from \"../settings/setting_elements/Autocomplete\";\r\nimport {getFolderPath} from \"./VariableHelpers\";\r\n\r\nexport class Variable_NewNoteFolderPath extends Variable {\r\n    public variable_name = \"new_note_folder_path\";\r\n    public help_text = \"Gives path to the \\\"Default location for new notes\\\" folder (a setting in Obsidian), either as absolute from the root of the file system, or as relative from the root of the Obsidian vault.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        mode: {\r\n            options: [\"absolute\", \"relative\"],\r\n            required: true,\r\n        }\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {mode: \"absolute\" | \"relative\"}): Promise<string> {\r\n        const current_file = this.app.workspace.getActiveFile(); // Needed just in case new notes should be created in the same folder as the currently open file.\r\n        const folder = this.app.fileManager.getNewFileParent(current_file ? current_file.path : \"\"); // If no file is open, use an empty string as instructed in .getNewFileParent()'s documentation.\r\n        if (folder) {\r\n            return getFolderPath(this.app, folder, castedArguments.mode);\r\n        } else {\r\n            this.throw(\"Cannot determine a folder path for new notes. Please create a discussion in GitHub.\"); // I guess this never happens.\r\n        }\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"Gives path to the \\\"Default location for new notes\\\" folder (a setting in Obsidian), absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":relative}}\",\r\n                help_text: \"Gives path to the \\\"Default location for new notes\\\" folder (a setting in Obsidian), relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":absolute}}\",\r\n                help_text: \"Gives path to the \\\"Default location for new notes\\\" folder (a setting in Obsidian), absolute from the root of the file system. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":relative}}\",\r\n                help_text: \"Gives path to the \\\"Default location for new notes\\\" folder (a setting in Obsidian), relative from the root of the Obsidian vault. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{folder_path:relative}}</strong> or <strong>{{folder_path:absolute}}</strong>\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {FileVariable} from \"./FileVariable\";\r\nimport {normalizePath} from \"obsidian\";\r\n\r\nexport class Variable_FileURI extends FileVariable{\r\n    public variable_name = \"file_uri\";\r\n    public help_text = \"Gives an Obsidian URI that opens the current file.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        return this.plugin.getObsidianURI(\"open\", {\r\n            file: normalizePath(this.getFileOrThrow().path), // Use normalizePath() instead of normalizePath2() because / should not be converted to \\ on Windows because this is used as a URI, not as a file system path.\r\n        });\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {\r\n    normalizePath,\r\n    TFile,\r\n} from \"obsidian\";\r\n\r\nexport class Variable_EventFileURI extends EventVariable {\r\n    public variable_name = \"event_file_uri\";\r\n    public help_text = \"Gives an Obsidian URI that opens the event related file.\";\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        argumentsAreNotUsed: never,\r\n        sc_event: SC_Event_FileMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        const file: TFile = sc_event.getFile();\r\n        return this.plugin.getObsidianURI(\"open\", {\r\n            file: normalizePath(file.path), // Use normalizePath() instead of normalizePath2() because / should not be converted to \\ on Windows because this is used as a URI, not as a file system path.\r\n        });\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {FileVariable} from \"./FileVariable\";\r\nimport {getFileContentWithoutYAML} from \"../Common\";\r\n\r\nexport class Variable_NoteContent extends FileVariable {\r\n    public variable_name = \"note_content\";\r\n    public help_text = \"Gives the current note's content without YAML frontmatter. If you need YAML included, use {{file_content}} instead.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        return await getFileContentWithoutYAML(this.app, this.getFileOrThrow());\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {getFileContentWithoutYAML} from \"../../Common\";\r\n\r\nexport class Variable_EventNoteContent extends EventVariable {\r\n    public variable_name = \"event_note_content\";\r\n    public help_text = \"Gives the event related file's content without YAML frontmatter. If you need YAML included, use {{event_file_content}} instead.\";\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        argumentsAreNotUsed: never,\r\n        sc_event: SC_Event_FileMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        return await getFileContentWithoutYAML(this.app, sc_event.getFile());\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {FileVariable} from \"./FileVariable\";\r\n\r\nexport class Variable_FileContent extends FileVariable {\r\n    public variable_name = \"file_content\";\r\n    public help_text = \"Gives the current file's content, including YAML frontmatter. If you need YAML excluded, use {{note_content}} instead.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        // Retrieve file content.\r\n        return await app.vault.read(this.getFileOrThrow());\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\n\r\nexport class Variable_EventFileContent extends EventVariable {\r\n    public variable_name = \"event_file_content\";\r\n    public help_text = \"Gives the event related file's content, including YAML frontmatter. If you need YAML excluded, use {{event_note_content}} instead.\";\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected async generateValue(\r\n        argumentsAreNotUsed: never,\r\n        sc_event: SC_Event_FileMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        this.requireCorrectEvent(sc_event);\r\n\r\n        // Retrieve file content.\r\n        return await app.vault.read(sc_event.getFile());\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EditorVariable} from \"./EditorVariable\";\r\n\r\nexport class Variable_CaretParagraph extends EditorVariable {\r\n    public variable_name = \"caret_paragraph\";\r\n    public help_text = \"Gives a text line at the current caret position.\";\r\n\r\n    protected async generateValue(): Promise<string> {\r\n        const editor = this.getEditorOrThrow();\r\n        this.requireViewModeSource();\r\n\r\n        const caretPosition = editor.getCursor('to');\r\n        return editor.getLine(caretPosition.line);\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return super.getAvailabilityText() + \" Not available in preview mode.\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {IParameters, Variable} from \"./Variable\";\r\n\r\nexport class Variable_Newline extends Variable {\r\n    public variable_name = \"newline\";\r\n    public help_text = \"Gives a \\\\n character. Used for testing line break escaping. An optional argument can be used to tell how many newlines are needed.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        count: {\r\n            type: \"integer\",\r\n            required: false,\r\n        }\r\n    };\r\n\r\n    protected async generateValue(castedArguments: {count?: number}): Promise<string> {\r\n        // Return \\n, possibly repeating it\r\n        return \"\\n\".repeat(castedArguments.count ?? 1);\r\n    }\r\n\r\n    public getAvailabilityText() {\r\n        return \"<strong>Only available</strong> in debug mode.\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {FileVariable} from \"./FileVariable\";\r\nimport {getFileYAML} from \"../Common\";\r\nimport {IParameters} from \"./Variable\";\r\nimport {IAutocompleteItem} from \"../settings/setting_elements/Autocomplete\";\r\nimport {TFile} from \"obsidian\";\r\n\r\nexport class Variable_YAMLContent extends FileVariable {\r\n    public variable_name = \"yaml_content\";\r\n    public help_text = \"Gives the current note's YAML frontmatter. Dashes --- can be included or excluded.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        withDashes: {\r\n            options: [\"with-dashes\", \"no-dashes\"],\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected generateValue(castedArguments: {withDashes: \"with-dashes\" | \"no-dashes\"}): Promise<string> {\r\n        return new Promise((resolve, reject) => {\r\n            let file: TFile;\r\n            try {\r\n                file = this.getFileOrThrow();\r\n            } catch (error) {\r\n                // Need to catch here, because Variable.getValue()'s .catch() block won't be able to catch thrown errors,\r\n                // it can only catch errors that were passed to reject().\r\n                reject(error);\r\n                return;\r\n            }\r\n\r\n            getFileYAML(this.app, file, \"with-dashes\" === castedArguments.withDashes).then((yamlContent: string) => {\r\n                if (null === yamlContent) {\r\n                    // No YAML frontmatter.\r\n                    this.reject(\"The current file does not contain a YAML frontmatter.\", reject);\r\n                } else {\r\n                    // Got a YAML frontmatter.\r\n                    resolve(yamlContent);\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return super.getAvailabilityText() + \" Also, a YAML frontmatter section needs to be present.\";\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":with-dashes}}\",\r\n                help_text: \"Gives the current note's YAML frontmatter, wrapped between --- lines. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":no-dashes}}\",\r\n                help_text: \"Gives the current note's YAML frontmatter, excluding top and bottom --- lines. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":with-dashes}}\",\r\n                help_text: \"Gives the current note's YAML frontmatter, wrapped between --- lines.\" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":no-dashes}}\",\r\n                help_text: \"Gives the current note's YAML frontmatter, excluding top and bottom --- lines. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{yaml_content:with-dashes}}</strong> or <strong>{{yaml_content:no-dashes}}</strong>\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {EventVariable} from \"./EventVariable\";\r\nimport {SC_Event_FileMenu} from \"../../events/SC_Event_FileMenu\";\r\nimport {SC_Event_FileCreated} from \"../../events/SC_Event_FileCreated\";\r\nimport {SC_Event_FileContentModified} from \"../../events/SC_Event_FileContentModified\";\r\nimport {SC_Event_FileDeleted} from \"../../events/SC_Event_FileDeleted\";\r\nimport {SC_Event_FileRenamed} from \"../../events/SC_Event_FileRenamed\";\r\nimport {SC_Event_FileMoved} from \"../../events/SC_Event_FileMoved\";\r\nimport {getFileYAML} from \"../../Common\";\r\nimport {IAutocompleteItem} from \"../../settings/setting_elements/Autocomplete\";\r\nimport {IParameters} from \"../Variable\";\r\n\r\nexport class Variable_EventYAMLContent extends EventVariable {\r\n    public variable_name = \"event_yaml_content\";\r\n    public help_text = \"Gives the event related note's YAML frontmatter. Dashes --- can be included or excluded.\";\r\n\r\n    protected static readonly parameters: IParameters = {\r\n        withDashes: {\r\n            options: [\"with-dashes\", \"no-dashes\"],\r\n            required: true,\r\n        },\r\n    };\r\n\r\n    protected supported_sc_events = [\r\n        SC_Event_FileMenu,\r\n        SC_Event_FileCreated,\r\n        SC_Event_FileContentModified,\r\n        SC_Event_FileDeleted,\r\n        SC_Event_FileMoved,\r\n        SC_Event_FileRenamed,\r\n    ];\r\n\r\n    protected generateValue(\r\n        castedArguments: {withDashes: \"with-dashes\" | \"no-dashes\"},\r\n        sc_event: SC_Event_FileMenu | SC_Event_FileCreated | SC_Event_FileContentModified | SC_Event_FileDeleted | SC_Event_FileMoved | SC_Event_FileRenamed,\r\n    ): Promise<string> {\r\n        return new Promise((resolve, reject) => {\r\n            try {\r\n                this.requireCorrectEvent(sc_event);\r\n            } catch (error) {\r\n                // Need to catch here, because Variable.getValue()'s .catch() block won't be able to catch thrown errors,\r\n                // it can only catch errors that were passed to reject().\r\n                reject(error);\r\n                return;\r\n            }\r\n\r\n            getFileYAML(this.app, sc_event.getFile(), castedArguments.withDashes === \"with-dashes\").then((yamlContent: string) => {\r\n                if (null === yamlContent) {\r\n                    // No YAML frontmatter.\r\n                    this.reject(\"The event related file does not contain a YAML frontmatter.\", reject);\r\n                } else {\r\n                    // Got a YAML frontmatter.\r\n                    resolve(yamlContent);\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n    public getAvailabilityText(): string {\r\n        return super.getAvailabilityText() + \" Also, a YAML frontmatter section needs to be present.\";\r\n    }\r\n\r\n    public getAutocompleteItems() {\r\n        return [\r\n            // Normal variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":with-dashes}}\",\r\n                help_text: \"Gives the event related note's YAML frontmatter, wrapped between --- lines. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{\" + this.variable_name + \":no-dashes}}\",\r\n                help_text: \"Gives the event related note's YAML frontmatter, excluding top and bottom --- lines. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"normal-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n\r\n            // Unescaped variables\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":with-dashes}}\",\r\n                help_text: \"Gives the event related note's YAML frontmatter, wrapped between --- lines.\" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n            <IAutocompleteItem>{\r\n                value: \"{{!\" + this.variable_name + \":no-dashes}}\",\r\n                help_text: \"Gives the event related note's YAML frontmatter, excluding top and bottom --- lines. \" + this.getAvailabilityText(),\r\n                group: \"Variables\",\r\n                type: \"unescaped-variable\",\r\n                documentationLink: this.getDocumentationLink(),\r\n            },\r\n        ];\r\n    }\r\n\r\n    public getHelpName(): string {\r\n        return \"<strong>{{event_yaml_content:with-dashes}}</strong> or <strong>{{event_yaml_content:no-dashes}}</strong>\";\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Variable} from \"./Variable\";\r\nimport {Variable_Clipboard} from \"./Variable_Clipboard\";\r\nimport {Variable_CaretPosition} from \"./Variable_CaretPosition\";\r\nimport {Variable_Date} from \"./Variable_Date\";\r\nimport {Variable_FileExtension} from \"./Variable_FileExtension\";\r\nimport {Variable_FileName} from \"./Variable_FileName\";\r\nimport {Variable_FilePath} from \"./Variable_FilePath\";\r\nimport {Variable_FolderName} from \"./Variable_FolderName\";\r\nimport {Variable_FolderPath} from \"./Variable_FolderPath\";\r\nimport {Variable_Selection} from \"./Variable_Selection\";\r\nimport {Variable_Tags} from \"./Variable_Tags\";\r\nimport {Variable_Title} from \"./Variable_Title\";\r\nimport {Variable_VaultPath} from \"./Variable_VaultPath\";\r\nimport {Variable_Workspace} from \"./Variable_Workspace\";\r\nimport {DEBUG_ON} from \"../Debug\";\r\nimport {Variable_Passthrough} from \"./Variable_Passthrough\";\r\nimport SC_Plugin from \"../main\";\r\nimport {Variable_YAMLValue} from \"./Variable_YAMLValue\";\r\nimport {Variable_EventFileName} from \"./event_variables/Variable_EventFileName\";\r\nimport {Variable_EventFilePath} from \"./event_variables/Variable_EventFilePath\";\r\nimport {Variable_EventFolderName} from \"./event_variables/Variable_EventFolderName\";\r\nimport {Variable_EventFolderPath} from \"./event_variables/Variable_EventFolderPath\";\r\nimport {Variable_EventTitle} from \"./event_variables/Variable_EventTitle\";\r\nimport {Variable_EventFileExtension} from \"./event_variables/Variable_EventFileExtension\";\r\nimport {Variable_EventTags} from \"./event_variables/Variable_EventTags\";\r\nimport {Variable_EventYAMLValue} from \"./event_variables/Variable_EventYAMLValue\";\r\nimport {CustomVariableInstance} from \"../models/custom_variable/CustomVariableInstance\";\r\nimport {Variable_Environment} from \"./Variable_Environment\";\r\nimport {Variable_EventOldFileName} from \"./event_variables/Variable_EventOldFileName\";\r\nimport {Variable_EventOldFilePath} from \"./event_variables/Variable_EventOldFilePath\";\r\nimport {Variable_EventOldFolderName} from \"./event_variables/Variable_EventOldFolderName\";\r\nimport {Variable_EventOldFolderPath} from \"./event_variables/Variable_EventOldFolderPath\";\r\nimport {Variable_EventOldTitle} from \"./event_variables/Variable_EventOldTitle\";\r\nimport {Variable_NewNoteFolderName} from \"./Variable_NewNoteFolderName\";\r\nimport {Variable_NewNoteFolderPath} from \"./Variable_NewNoteFolderPath\";\r\nimport {Variable_FileURI} from \"./Variable_FileURI\";\r\nimport {Variable_EventFileURI} from \"./event_variables/Variable_EventFileURI\";\r\nimport {Variable_NoteContent} from \"./Variable_NoteContent\";\r\nimport {Variable_EventNoteContent} from \"./event_variables/Variable_EventNoteContent\";\r\nimport {Variable_FileContent} from \"./Variable_FileContent\";\r\nimport {Variable_EventFileContent} from \"./event_variables/Variable_EventFileContent\";\r\nimport {Variable_CaretParagraph} from \"./Variable_CaretParagraph\";\r\nimport {Variable_Newline} from \"./Variable_Newline\";\r\nimport {Variable_YAMLContent} from \"./Variable_YAMLContent\";\r\nimport {Variable_EventYAMLContent} from \"./event_variables/Variable_EventYAMLContent\";\r\n\r\n\r\nexport function loadVariables(plugin: SC_Plugin): VariableSet {\r\n\r\n    const variables = new VariableSet([]);\r\n\r\n    // Load CustomVariables\r\n    // Do this before loading built-in variables so that these user-defined variables will appear first in all lists containing variables.\r\n    plugin.getCustomVariableInstances().forEach((custom_variable_instance: CustomVariableInstance) => {\r\n        variables.add(custom_variable_instance.createCustomVariable());\r\n    });\r\n\r\n    // Load built-in variables.\r\n    const built_in_variables: Variable[] = [\r\n        // Normal variables\r\n        new Variable_CaretParagraph(plugin),\r\n        new Variable_CaretPosition(plugin),\r\n        new Variable_Clipboard(plugin),\r\n        new Variable_Date(plugin),\r\n        new Variable_Environment(plugin),\r\n        new Variable_FileContent(plugin),\r\n        new Variable_FileExtension(plugin),\r\n        new Variable_FileName(plugin),\r\n        new Variable_FilePath(plugin),\r\n        new Variable_FileURI(plugin),\r\n        new Variable_FolderName(plugin),\r\n        new Variable_FolderPath(plugin),\r\n        new Variable_NewNoteFolderName(plugin),\r\n        new Variable_NewNoteFolderPath(plugin),\r\n        new Variable_NoteContent(plugin),\r\n        // Variable_Output is not loaded here, because it's only used in OutputWrappers.\r\n        new Variable_Selection(plugin),\r\n        new Variable_Tags(plugin),\r\n        new Variable_Title(plugin),\r\n        new Variable_VaultPath(plugin),\r\n        new Variable_Workspace(plugin),\r\n        new Variable_YAMLContent(plugin),\r\n        new Variable_YAMLValue(plugin),\r\n\r\n        // Event variables\r\n        new Variable_EventFileContent(plugin),\r\n        new Variable_EventFileExtension(plugin),\r\n        new Variable_EventFileName(plugin),\r\n        new Variable_EventFilePath(plugin),\r\n        new Variable_EventFileURI(plugin),\r\n        new Variable_EventFolderName(plugin),\r\n        new Variable_EventFolderPath(plugin),\r\n        new Variable_EventNoteContent(plugin),\r\n        new Variable_EventOldFileName(plugin),\r\n        new Variable_EventOldFilePath(plugin),\r\n        new Variable_EventOldFolderName(plugin),\r\n        new Variable_EventOldFolderPath(plugin),\r\n        new Variable_EventOldTitle(plugin),\r\n        new Variable_EventTags(plugin),\r\n        new Variable_EventTitle(plugin),\r\n        new Variable_EventYAMLContent(plugin),\r\n        new Variable_EventYAMLValue(plugin),\r\n    ];\r\n    if (DEBUG_ON) {\r\n        // Variables that are only designed for 'Shell commands test suite'.\r\n        built_in_variables.push(\r\n            new Variable_Newline(plugin),\r\n            new Variable_Passthrough(plugin),\r\n        );\r\n    }\r\n    for (const built_in_variable of built_in_variables) {\r\n        // JavaScript's Set does not have a method to add multiple items at once, so need to iterate them and add one-by-one.\r\n        variables.add(built_in_variable);\r\n    }\r\n\r\n    return variables;\r\n}\r\n\r\nexport class VariableSet extends Set<Variable> {}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../main\";\r\nimport {debugLog} from \"../Debug\";\r\nimport {SC_Event} from \"../events/SC_Event\";\r\nimport {escapeValue} from \"./escapers/EscapeValue\";\r\nimport {VariableSet} from \"./loadVariables\";\r\nimport {\r\n    IRawArguments,\r\n    Variable,\r\n    VariableValueResult,\r\n} from \"./Variable\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {removeFromSet} from \"../Common\";\r\n\r\n/**\r\n * @param plugin\r\n * @param content\r\n * @param shell Used to determine how to escape special characters in variable values. Can be null, if no escaping is wanted.\r\n * @param t_shell_command Will only be used to read default value configurations. Can be null if no TShellCommand is available, but then no default values can be accessed.\r\n * @param sc_event Use undefined, if parsing is not happening during an event.\r\n * @param variables If you want to parse only a certain set of variables, define them in this parameter. If this is omitted, all variables will be parsed.\r\n * @param raw_value_augmenter A callback that will be called before every substitution. Allows modifying or completely changing the resulted variable values.\r\n * @param escaped_value_augmenter Same as raw_value_augmenter, but called after escaping the value. Can be used to for example wrap values in html elements for displaying purposes.\r\n * @return ParsingResult\r\n */\r\nexport async function parseVariables(\r\n        plugin: SC_Plugin,\r\n        content: string,\r\n        shell: string | null,\r\n        t_shell_command: TShellCommand | null,\r\n        sc_event?: SC_Event | null,\r\n        variables: VariableSet = plugin.getVariables(),\r\n        raw_value_augmenter: ((variable: Variable, raw_value: VariableValueResult) => void) | null = null,\r\n        escaped_value_augmenter: ((variable: Variable, escaped_value: string) => string) | null = null,\r\n    ): Promise<ParsingResult> {\r\n\r\n    debugLog(\"parseVariables(): Starting to parse \" + content + \" with \" + variables.size + \" variables.\");\r\n\r\n    // Initialize a parsing result object\r\n    const parsing_result: ParsingResult = {\r\n        original_content: content,\r\n        parsed_content: content, // Create a copy of the variable because we don't want to alter the original value of 'content' during iterating its regex matches. Originally this copy was just another local variable, but now it's changed to be a property in an object.\r\n        succeeded: false,\r\n        error_messages: [],\r\n        count_parsed_variables: 0,\r\n    };\r\n\r\n    for (const variable of variables)\r\n    {\r\n        const pattern = new RegExp(variable.getPattern(), \"igu\"); // i: case-insensitive; g: match all occurrences instead of just the first one. u: support 4-byte unicode characters too.\r\n        const parameter_names = variable.getParameterNames();\r\n        let argument_matches: RegExpExecArray | null;\r\n        while ((argument_matches = pattern.exec(content)) !== null) {\r\n            // Count how many times any variables have appeared.\r\n            parsing_result.count_parsed_variables++;\r\n\r\n            // Remove stuff that should not be iterated in a later loop.\r\n            /** Need to prefix with _ because JavaScript reserves the variable name 'arguments'. */\r\n            const _arguments = argument_matches.filter((value: unknown /* Won't be used */, key: unknown) => {\r\n                return \"number\" === typeof key;\r\n                // This leaves out for example the following non-numeric keys (and their values):\r\n                // - \"groups\"\r\n                // - \"index\"\r\n                // - \"input\"\r\n                // In the future, there can also come more elements that will be skipped. E.g. \"indices\". See: https://github.com/nothingislost/obsidian-dynamic-highlights/issues/25#issuecomment-1038563990 (referenced 2022-02-22).\r\n            });\r\n\r\n            // Get the {{variable}} string that will be substituted (= replaced with the actual value of the variable).\r\n            const substitute: string = _arguments.shift() as string; // '_arguments[0]' contains the whole match, not just an argument. Get it and remove it from '_arguments'. 'as string' is used to tell TypeScript that _arguments[0] is always defined.\r\n\r\n            // Iterate all arguments\r\n            const presentArguments: IRawArguments = {};\r\n            for (const i in _arguments) {\r\n                // Check that the argument is not omitted. It can be omitted (= undefined), if the parameter is optional.\r\n                if (undefined !== _arguments[i]) {\r\n                    // The argument is present.\r\n                    const argument = _arguments[i].slice(1); // .slice(1): Remove a preceding :\r\n                    const parameter_name = parameter_names[i];\r\n                    presentArguments[parameter_name] = argument;\r\n                }\r\n            }\r\n\r\n            // Should the variable's value be escaped? (Usually yes).\r\n            let escape = true;\r\n            if (\"{{!\" === substitute.slice(0, 3)) { // .slice(0, 3) = get characters 0...2, so stop before 3. The 'end' parameter is confusing.\r\n                // The variable usage begins with {{! instead of {{\r\n                // This means the variable's value should NOT be escaped.\r\n                escape = false;\r\n            }\r\n            if (!shell) {\r\n                // Escaping is forced OFF.\r\n                escape = false;\r\n            }\r\n\r\n            // Render the variable\r\n            const variable_value_result = await variable.getValue(\r\n                t_shell_command,\r\n                sc_event,\r\n                presentArguments,\r\n\r\n                // Define a recursive callback that can be used to parse possible variables in a default value of the current variable.\r\n                (raw_default_value) => {\r\n                    // Avoid circular references by removing the current variable from the set of parseable variables.\r\n                    // This will cumulate in deep nested parsing: Possible deeper parsing rounds will always have narrower\r\n                    // and narrower sets of variables to parse.\r\n                    const reduced_variables = removeFromSet(variables, variable);\r\n                    return parseVariables(\r\n                        plugin,\r\n                        raw_default_value,\r\n                        null, // Disable escaping special characters at this phase to avoid double escaping, as escaping will be done later.\r\n                        t_shell_command,\r\n                        sc_event,\r\n                        reduced_variables,\r\n                        raw_value_augmenter,\r\n                        escaped_value_augmenter,\r\n                    );\r\n                },\r\n            );\r\n\r\n            // Allow custom modification of the raw value.\r\n            if (raw_value_augmenter) {\r\n                // The augmenter can modify the content of the variable_value_result object.\r\n                raw_value_augmenter(variable, variable_value_result);\r\n            }\r\n            const raw_variable_value = variable_value_result.value;\r\n\r\n            // Check possible error messages that might have come from rendering.\r\n            if (variable_value_result.succeeded) {\r\n                // Parsing was ok.\r\n\r\n                // Escape the value if needed.\r\n                let use_variable_value: string;\r\n                if (escape) {\r\n                    // Use an escaped value.\r\n                    use_variable_value = escapeValue(\r\n                        shell as string, // shell is always a string when escape is true.\r\n                        raw_variable_value as string, // raw_variable_value is always a string when variable_value_result.succeeded is true.\r\n                    );\r\n                } else {\r\n                    // No escaping is wanted, so use the raw value.\r\n                    use_variable_value = raw_variable_value as string; // raw_variable_value is always a string when variable_value_result.succeeded is true.\r\n                }\r\n\r\n                // Augment the escaped value, if wanted.\r\n                if (escaped_value_augmenter) {\r\n                    use_variable_value = escaped_value_augmenter(variable, use_variable_value);\r\n                }\r\n\r\n                // Replace the variable name with the variable value.\r\n                parsing_result.parsed_content = (parsing_result.parsed_content as string /* not null */).replace(substitute, () => {\r\n                    // Do the replacing in a function in order to avoid a possible $ character to be interpreted by JavaScript to interact with the regex.\r\n                    // More information: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter (referenced 2021-11-02.)\r\n                    return use_variable_value;\r\n                });\r\n            } else {\r\n                // There has been problem(s) with this variable.\r\n                debugLog(\"parseVariables(): Parsing content \" + content + \" failed.\");\r\n                parsing_result.succeeded = false;\r\n                parsing_result.parsed_content = null;\r\n                parsing_result.error_messages = variable_value_result.error_messages; // Returning now prevents parsing rest of the variables.\r\n                return parsing_result;\r\n            }\r\n        }\r\n    }\r\n    debugLog(\"parseVariables(): Parsing content \" + content + \" succeeded.\");\r\n    parsing_result.succeeded = true;\r\n    return parsing_result;\r\n}\r\n\r\n/**\r\n * Reads all variables from the content string, and returns a VariableSet containing all the found variables.\r\n *\r\n * This is needed in situations where variables will not be parsed (= variable values are not needed), but where it's just\r\n * needed to know what variables e.g. a shell command relies on.\r\n *\r\n * @param plugin\r\n * @param content\r\n */\r\nexport function getUsedVariables(\r\n        plugin: SC_Plugin,\r\n        content: string,\r\n    ): VariableSet {\r\n    const search_for_variables: VariableSet = plugin.getVariables();\r\n    const found_variables = new VariableSet();\r\n    \r\n    for (const variable of search_for_variables)\r\n    {\r\n        const pattern = new RegExp(variable.getPattern(), \"igu\"); // i: case-insensitive; g: match all occurrences instead of just the first one. u: support 4-byte unicode characters too.\r\n        if (pattern.exec(content) !== null) {\r\n            // This variable was found.\r\n            found_variables.add(variable);\r\n        }\r\n    }\r\n\r\n    return found_variables;\r\n}\r\n\r\nexport interface ParsingResult {\r\n    original_content: string;\r\n\r\n    /**\r\n     * This is null if succeeded is false.\r\n     * */\r\n    parsed_content: string | null;\r\n\r\n    succeeded: boolean;\r\n    error_messages: string[];\r\n    count_parsed_variables: number;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../main\";\r\nimport {App} from \"obsidian\";\r\nimport {OutputStreams} from \"./OutputChannelFunctions\";\r\nimport {\r\n    OutputHandlingMode,\r\n    OutputStream,\r\n} from \"./OutputChannelCode\";\r\nimport {debugLog} from \"../Debug\";\r\nimport {ShellCommandParsingResult, TShellCommand} from \"../TShellCommand\";\r\nimport {joinObjectProperties} from \"../Common\";\r\nimport {Variable_Output} from \"../variables/Variable_Output\";\r\nimport {parseVariables} from \"../variables/parseVariables\";\r\nimport {VariableSet} from \"../variables/loadVariables\";\r\n\r\nexport abstract class OutputChannel {\r\n\r\n    // Class specific properties\r\n    /**\r\n     * Human readable name, used in settings.\r\n     */\r\n    protected static readonly title: string;\r\n    protected static readonly accepted_output_streams: OutputStream[] = [\"stdout\", \"stderr\"];\r\n    protected static readonly accepts_empty_output: boolean = false;\r\n\r\n    /**\r\n     * Determines if the output channel wants to handle a unified output or not. If yes, this property should define a\r\n     * delimiter string that will be used as a glue between different output streams.\r\n     *\r\n     * @protected\r\n     */\r\n    protected static readonly combine_output_streams: false | string = false;\r\n\r\n    /**\r\n     * Used in OutputModal to redirect output based on hotkeys. If this is undefined, then the output channel is completely\r\n     * excluded from OutputModal.\r\n     */\r\n    public static readonly hotkey_letter: string | undefined = undefined;\r\n\r\n    /**\r\n     * Can be overridden in child classes in order to vary the title depending on output_stream.\r\n     * @param output_stream\r\n     */\r\n    public static getTitle(output_stream: OutputStream) {\r\n        return this.title;\r\n    }\r\n\r\n    // Instance specific properties\r\n    protected app: App;\r\n\r\n    /**\r\n     * @param plugin\r\n     * @param t_shell_command\r\n     * @param shell_command_parsing_result\r\n     * @param outputHandlingMode\r\n     * @param processTerminator Will be called if user decides to end the process. Set to null if the process has already ended.\r\n     */\r\n    public constructor(\r\n        protected plugin: SC_Plugin,\r\n        protected t_shell_command: TShellCommand,\r\n        protected shell_command_parsing_result: ShellCommandParsingResult,\r\n        protected outputHandlingMode: OutputHandlingMode,\r\n        protected processTerminator: (() => void) | null,\r\n    ) {\r\n        this.app = plugin.app;\r\n        this.initialize();\r\n    }\r\n\r\n    /**\r\n     * Sub classes can do here initializations that are common to both handleBuffered() and handleRealtime().\r\n     *\r\n     * Inits could be done in contructor(), too, but this is cleaner - no need to deal with parameters and no need for a super()\r\n     * call.\r\n     *\r\n     * @protected\r\n     */\r\n    protected initialize() {\r\n        // Do nothing by default.\r\n    }\r\n\r\n    /**\r\n     * @param output Subclasses should define this as string, if they enable 'combine_output_streams'. Otherwise, they should define this as OutputStreams.\r\n     * @param error_code\r\n     * @protected\r\n     */\r\n    protected abstract _handleBuffered(output: OutputStreams | string, error_code: number | null): Promise<void>;\r\n\r\n    public async handleBuffered(output: OutputStreams, error_code: number | null, enableOutputWrapping = true): Promise<void> {\r\n        this.requireHandlingMode(\"buffered\");\r\n\r\n        // Qualify output\r\n        if (OutputChannel.isOutputEmpty(output)) {\r\n            // The output is empty\r\n            if (!this.static().accepts_empty_output) {\r\n                // This OutputChannel does not accept empty output, i.e. empty output should be just ignored.\r\n                debugLog(this.constructor.name + \".handleBuffered(): Ignoring empty output.\");\r\n                return;\r\n            }\r\n        }\r\n        debugLog(this.constructor.name + \".handleBuffered(): Handling output...\");\r\n\r\n        // Output is ok.\r\n        // Handle it.\r\n        await this._handleBuffered(await this.prepare_output(output, enableOutputWrapping), error_code);\r\n        debugLog(\"Output handling is done.\");\r\n    }\r\n\r\n    protected abstract _handleRealtime(outputContent: string, outputStreamName: OutputStream): Promise<void>;\r\n\r\n    /**\r\n     * @param outputStreamName\r\n     * @param outputContent\r\n     * @param enableOutputWrapping No caller actually sets this to false at the moment, unlike the handleBuffered() method's counterpart. But have this just in case.\r\n     */\r\n    public async handleRealtime(outputStreamName: OutputStream, outputContent: string, enableOutputWrapping = true) {\r\n        this.requireHandlingMode(\"realtime\");\r\n\r\n        // Qualify output\r\n        if (\"\" === outputContent) {\r\n            // The output is empty\r\n            if (!this.static().accepts_empty_output) {\r\n                // This OutputChannel does not accept empty output, i.e. empty output should be just ignored.\r\n                debugLog(this.constructor.name + \".handleRealtime(): Ignoring empty output.\");\r\n                return;\r\n            }\r\n        }\r\n        debugLog(this.constructor.name + \".handleRealtime(): Handling output...\");\r\n\r\n        // Output is ok.\r\n\r\n        // If allowed, wrap the output with output wrapper text.\r\n        if (enableOutputWrapping) {\r\n            // Wrap output (but only if a wrapper is defined)\r\n            outputContent = await this.wrapOutput(outputStreamName, outputContent);\r\n        }\r\n\r\n        // Handle it.\r\n        await this._handleRealtime(outputContent, outputStreamName);\r\n\r\n        debugLog(\"Output handling is done.\");\r\n    }\r\n\r\n    protected _endRealtime(exitCode: number): void {\r\n        // Do nothing by default.\r\n    }\r\n\r\n    /**\r\n     * When a shell command is executed in \"realtime\" mode, a separate ending call should be made in order to pass an\r\n     * exit code to the OutputChannel. Some OutputChannels display the code to user, but most do not.\r\n     *\r\n     * @param exitCode\r\n     */\r\n    public endRealtime(exitCode: number) {\r\n        this.requireHandlingMode(\"realtime\");\r\n\r\n        this._endRealtime(exitCode);\r\n    }\r\n\r\n    private requireHandlingMode(requiredMode: OutputHandlingMode) {\r\n        if (this.outputHandlingMode !== requiredMode) {\r\n            throw new Error(\"this.outputHandlingMode must be '\"+requiredMode+\"'.\");\r\n        }\r\n    }\r\n\r\n    public static acceptsOutputStream(output_stream: OutputStream) {\r\n        return this.accepted_output_streams.contains(output_stream);\r\n    }\r\n\r\n    /**\r\n     * Does the following preparations:\r\n     *  - Combines output streams (if wanted by the OutputChannel).\r\n     *  - Wraps output (if defined in shell command configuration).\r\n     * @param output_streams\r\n     * @param enableOutputWrapping\r\n     * @private\r\n     */\r\n    private async prepare_output(output_streams: OutputStreams, enableOutputWrapping: boolean): Promise<OutputStreams | string> {\r\n        const wrapOutputIfEnabled = async (outputStreamName: OutputStream, outputContent: string) => {\r\n            if (enableOutputWrapping) {\r\n                // Wrap output content.\r\n                return await this.wrapOutput(outputStreamName, outputContent);\r\n            } else {\r\n                // Wrapping is disabled, return unmodified output content.\r\n                return outputContent;\r\n            }\r\n        };\r\n\r\n        const wrap_outputs_separately = async () => {\r\n            const wrapped_output_streams: OutputStreams = {};\r\n            let output_stream_name: OutputStream;\r\n            for (output_stream_name in output_streams) {\r\n                wrapped_output_streams[output_stream_name] = await wrapOutputIfEnabled(\r\n                    output_stream_name,\r\n                    output_streams[output_stream_name] as string, // as string = output content always exists because the key came from for...in.\r\n                );\r\n            }\r\n            return wrapped_output_streams;\r\n        };\r\n\r\n        // Check if outputs should be combined.\r\n        const combineOutputStreams = this.static().combine_output_streams;\r\n        if (combineOutputStreams) {\r\n            // Combine output strings into a single string.\r\n\r\n            // Can output wrapping be combined?\r\n            if (this.t_shell_command.isOutputWrapperStdoutSameAsStderr()) {\r\n                // Output wrapping can be combined.\r\n                return await wrapOutputIfEnabled(\r\n                    \"stdout\",\r\n                    joinObjectProperties(output_streams, combineOutputStreams), // Use combineOutputStreams as a glue string.\r\n                );\r\n            } else {\r\n                // Output wrapping needs to be done separately.\r\n                const wrapped_output_streams = await wrap_outputs_separately();\r\n                return joinObjectProperties(wrapped_output_streams, combineOutputStreams); // Use combineOutputStreams as a glue string.\r\n            }\r\n\r\n        } else {\r\n            // Do not combine, handle each stream separately\r\n            return await wrap_outputs_separately();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Surrounds the given output text with an output wrapper. If no output wrapper is defined, returns the original\r\n     * output text without any modifications.\r\n     */\r\n    private async wrapOutput(output_stream: OutputStream, output_content: string): Promise<string> {\r\n\r\n        // Get preparsed output wrapper content. It has all other variables parsed, except {{output}}.\r\n        const parsing_result_key: keyof ShellCommandParsingResult = \"output_wrapper_\"+output_stream as keyof ShellCommandParsingResult;\r\n        const output_wrapper_content = this.shell_command_parsing_result[parsing_result_key] as string | undefined;\r\n\r\n        // Check if output wrapper content exists.\r\n        if (undefined === output_wrapper_content) {\r\n            // No OutputWrapper is defined for this shell command.\r\n            // Return the output text without modifications.\r\n            debugLog(\"Output wrapping: No wrapper is defined for '\" + output_stream + \"'.\");\r\n            return output_content;\r\n        }\r\n\r\n        // Parse the {{output}} variable\r\n        const output_variable = new Variable_Output(this.plugin, output_content);\r\n        const parsing_result = await parseVariables(\r\n            this.plugin,\r\n            output_wrapper_content,\r\n            null, // No shell anymore, so no need for escaping.\r\n            this.t_shell_command,\r\n            null, // No support for {{event_*}} variables is needed, because they are already parsed in output_wrapper_content. This phase only parses {{output}} variable, nothing else.\r\n            new VariableSet([output_variable]), // Only parse the {{output}} variable.\r\n        );\r\n\r\n        // Inspect the parsing result. It should always succeed, as the {{output}} variable should not give any errors.\r\n        if (parsing_result.succeeded) {\r\n            // Succeeded.\r\n            debugLog(\"Output wrapping: Wrapping \" + output_stream + \" succeeded.\");\r\n            return parsing_result.parsed_content as string;\r\n        } else {\r\n            // Failed for some reason.\r\n            this.plugin.newError(\"Output wrapping failed, see error(s) below.\");\r\n            this.plugin.newErrors(parsing_result.error_messages);\r\n            throw new Error(\"Output wrapping failed: Parsing {{output}} resulted in error(s): \" + parsing_result.error_messages.join(\" \"));\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Can be moved to a global function isOutputStreamEmpty() if needed.\r\n     * @param output\r\n     * @private\r\n     */\r\n    private static isOutputEmpty(output: OutputStreams) {\r\n        if (undefined !== output.stderr) {\r\n            return false;\r\n        }\r\n        return undefined === output.stdout || \"\" === output.stdout;\r\n    }\r\n\r\n    public static() {\r\n        return this.constructor as typeof OutputChannel;\r\n    }\r\n}\r\n\r\nexport interface OutputChannels {\r\n    stdout?: OutputChannel,\r\n    stderr?: OutputChannel,\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {OutputChannel} from \"./OutputChannel\";\r\nimport {OutputStreams} from \"./OutputChannelFunctions\";\r\nimport {OutputStream} from \"./OutputChannelCode\";\r\nimport {Notice} from \"obsidian\";\r\n\r\n\r\nexport class OutputChannel_Notification extends OutputChannel {\r\n\r\n    /**\r\n     * All received output cumulatively. Subsequent handlings will then use the whole output, not just new parts.\r\n     * Only used in \"realtime\" mode.\r\n     *\r\n     * @private\r\n     */\r\n    private realtimeContentBuffer = \"\";\r\n\r\n    /**\r\n     * Holds a Notice instance so that the message can be updated during subsequent handlings.\r\n     * Only used in \"realtime\" mode.\r\n     *\r\n     * @private\r\n     */\r\n    private realtimeNotice: Notice | undefined;\r\n\r\n    private realtimeNoticeTimeout: number | undefined;\r\n\r\n    /**\r\n     * A flag for indicating that if any stderr output has happened, all subsequent handlings should format the output\r\n     * Notice message with error formatting (i.e. show [...] at the beginning of the message).\r\n     * @private\r\n     */\r\n    private realtimeHasStderrOccurred = false;\r\n\r\n    public static getTitle(output_stream: OutputStream): string {\r\n        switch (output_stream) {\r\n            case \"stdout\":\r\n                return \"Notification balloon\";\r\n            case \"stderr\":\r\n                return \"Error balloon\";\r\n        }\r\n    }\r\n\r\n    protected async _handleBuffered(output: OutputStreams, error_code: number | null): Promise<void> {\r\n\r\n        // Iterate output streams.\r\n        // There can be both \"stdout\" and \"stderr\" present at the same time, or just one of them. If both are present, two\r\n        // notifications will be created.\r\n        let output_stream_name: OutputStream;\r\n        for (output_stream_name in output) {\r\n            const output_message: string = output[output_stream_name] as string; // as string = output message is not undefined because of the for loop.\r\n            this.notify(output_stream_name, output_message, error_code);\r\n        }\r\n    }\r\n\r\n    protected async _handleRealtime(outputContent: string, outputStreamName: OutputStream): Promise<void> {\r\n\r\n        // Append new content\r\n        this.realtimeContentBuffer += outputContent;\r\n\r\n        // Raise a flag if seeing 'stderr' output.\r\n        if (\"stderr\" === outputStreamName) {\r\n            this.realtimeHasStderrOccurred = true;\r\n        }\r\n\r\n        // Does a Notice exist already?\r\n        if (this.realtimeNotice) {\r\n            // Reuse an existing Notice.\r\n\r\n            // Should output be formatted as an error message?\r\n            let updatedMessage: string;\r\n            if (this.realtimeHasStderrOccurred) {\r\n                // Apply error formatting to output\r\n                updatedMessage = OutputChannel_Notification.formatErrorMessage(this.realtimeContentBuffer, null);\r\n            } else {\r\n                // Use output as-is\r\n                updatedMessage = this.realtimeContentBuffer;\r\n            }\r\n\r\n            // Use the updated output\r\n            this.realtimeNotice.setMessage(updatedMessage);\r\n\r\n            // Update notice hiding timeout\r\n            window.clearTimeout(this.realtimeNoticeTimeout); // Remove old timeout\r\n            this.handleNotificationHiding(outputStreamName); // Add new timeout\r\n        } else {\r\n            // Create a new Notice.\r\n            this.realtimeNotice = this.notify(\r\n                this.realtimeHasStderrOccurred ? \"stderr\" : \"stdout\",\r\n                this.realtimeContentBuffer,\r\n                null,\r\n                0, // Use 0 timeout so that the Notice won't hide automatically.\r\n            );\r\n\r\n            // Create a timeout for hiding the Notice\r\n            this.handleNotificationHiding(outputStreamName);\r\n        }\r\n\r\n        // Terminating button\r\n        // @ts-ignore Notice.noticeEl belongs to Obsidian's PRIVATE API, and it may change without a prior notice. Only\r\n        // create the button if noticeEl exists and is an HTMLElement.\r\n        const noticeEl = this.realtimeNotice.noticeEl;\r\n        if (null === this.processTerminator) {\r\n            throw new Error(\"Process terminator is not set, although it should be set when handling output in realtime mode.\");\r\n        }\r\n        if (undefined !== noticeEl && noticeEl instanceof HTMLElement) {\r\n            this.plugin.createRequestTerminatingButton(noticeEl, this.processTerminator);\r\n        }\r\n    }\r\n\r\n    protected _endRealtime(exitCode: number | null): void {\r\n        if (exitCode !== 0 || this.realtimeHasStderrOccurred) {\r\n            // If a Notice exists, update it with the exitCode\r\n            this.realtimeNotice?.setMessage(OutputChannel_Notification.formatErrorMessage(\r\n                this.realtimeContentBuffer,\r\n                exitCode, // If exitCode is null, it means user terminated the process, and it will show up as \"[...]\". It's ok, it indicates that no exit code was received.\r\n            ));\r\n        }\r\n\r\n        // Remove terminating button\r\n        // @ts-ignore Notice.noticeEl belongs to Obsidian's PRIVATE API, and it may change without a prior notice. Only\r\n        // create the button if noticeEl exists and is an HTMLElement.\r\n        const noticeEl = this.realtimeNotice?.noticeEl;\r\n        if (undefined !== noticeEl && noticeEl instanceof HTMLElement) {\r\n            noticeEl.find(\".SC-icon-terminate-process\")?.remove(); // ? = Only try to remove if the button exists. It does not exist if .setMessage() was called above as it overwrites all content in the Notice.\r\n        }\r\n    }\r\n\r\n    /**\r\n     *\r\n     * @param outputStreamName\r\n     * @param outputContent\r\n     * @param exitCode\r\n     * @param noticeTimeout Allows overriding the notice/error timeout setting.\r\n     * @private\r\n     */\r\n    private notify(outputStreamName: OutputStream, outputContent: string, exitCode: number | null, noticeTimeout?: number): Notice {\r\n        switch (outputStreamName) {\r\n            case \"stdout\":\r\n                // Normal output\r\n                return this.plugin.newNotification(outputContent, noticeTimeout ?? undefined);\r\n            case \"stderr\":\r\n                // Error output\r\n                return this.plugin.newError(OutputChannel_Notification.formatErrorMessage(outputContent, exitCode), noticeTimeout ?? undefined);\r\n        }\r\n    }\r\n\r\n    private static formatErrorMessage(outputContent: string, exitCode: number | null): string {\r\n        if (null === exitCode) {\r\n            // If a \"realtime\" process is not finished, there is no exit code yet.\r\n            // @ts-ignore Yea I know \"...\" is not a number nor null. :)\r\n            exitCode = \"...\";\r\n        }\r\n        return \"[\" + exitCode + \"]: \" + outputContent;\r\n    }\r\n\r\n    private handleNotificationHiding(outputStreamName: OutputStream) {\r\n\r\n        // Hide by timeout\r\n        let normalTimeout: number;\r\n        switch (outputStreamName) {\r\n            case \"stdout\":\r\n                normalTimeout = this.plugin.getNotificationMessageDurationMs();\r\n                break;\r\n            case \"stderr\":\r\n                normalTimeout = this.plugin.getErrorMessageDurationMs();\r\n                break;\r\n        }\r\n        this.realtimeNoticeTimeout = window.setTimeout(\r\n            () => {\r\n                // Hide the Notice\r\n                this.realtimeNotice?.hide(); // ? = Don't try to hide if a user has closed the notification by clicking. See the 'this.realtimeNotice = undefined;' line in the below click handler.\r\n                this.realtimeNotice = undefined;\r\n                this.realtimeNoticeTimeout = undefined;\r\n            },\r\n            normalTimeout,\r\n        );\r\n\r\n        // Subscribe to Notice's click event.\r\n        // @ts-ignore Notice.noticeEl belongs to Obsidian's PRIVATE API, and it may change without a prior notice. Only\r\n        // define the click listener if noticeEl exists and is an HTMLElement.\r\n        const noticeEl = this.realtimeNotice.noticeEl;\r\n        if (undefined !== noticeEl && noticeEl instanceof HTMLElement) {\r\n            noticeEl.onClickEvent(() => {\r\n                window.clearTimeout(this.realtimeNoticeTimeout); // Make sure timeout will not accidentally try to later hide an already hidden Notification.\r\n                this.realtimeNoticeTimeout = undefined;\r\n                this.realtimeNotice = undefined; // Give a signal to _handleRealtime() that if new output comes, a new Notice should be created.\r\n            });\r\n        }\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {OutputChannel} from \"./OutputChannel\";\r\nimport {getEditor, getView} from \"../Common\";\r\nimport {Editor} from \"obsidian\";\r\nimport {debugLog} from \"../Debug\";\r\n\r\nexport abstract class OutputChannel_CurrentFile extends OutputChannel {\r\n\r\n    /**\r\n     * There can be both \"stdout\" and \"stderr\" present at the same time, or just one of them. If both are present, they\r\n     * will be joined together with \" \" as a separator.\r\n     * @protected\r\n     */\r\n    protected static readonly combine_output_streams = \" \";\r\n\r\n    protected async _handleBuffered(outputContent: string): Promise<void> {\r\n        this.handle(outputContent);\r\n    }\r\n\r\n    protected async _handleRealtime(outputContent: string): Promise<void> {\r\n        this.handle(outputContent);\r\n    }\r\n\r\n    private handle(output_message: string) {\r\n        const editor = getEditor(this.app);\r\n        const view = getView(this.app);\r\n\r\n        if (null === editor) {\r\n            // For some reason it's not possible to get an editor.\r\n            this.plugin.newError(\"Could not get an editor instance! Please create a discussion in GitHub. The command output is in the next error box:\");\r\n            this.plugin.newError(output_message); // Good to output it at least some way.\r\n            debugLog(\"OutputChannel_CurrentFile: Could not get an editor instance.\");\r\n            return;\r\n        }\r\n\r\n        // Check if the view is in source mode\r\n        if (null === view) {\r\n            // For some reason it's not possible to get an editor, but it's not a big problem.\r\n            debugLog(\"OutputChannel_CurrentFile: Could not get a view instance.\");\r\n        } else {\r\n            // We do have a view\r\n            if (\"source\" !== view.getMode()) {\r\n                // Warn that the output might go to an unexpected place in the note file.\r\n                this.plugin.newNotification(\"Note that your active note is not in 'Edit' mode! The output comes visible when you switch to 'Edit' mode again!\");\r\n            }\r\n        }\r\n\r\n        // Insert into the current file\r\n        this.insertIntoEditor(editor, output_message);\r\n    }\r\n\r\n    protected abstract insertIntoEditor(editor: Editor, output_message: string): void;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {OutputChannel_CurrentFile} from \"./OutputChannel_CurrentFile\";\r\nimport {Editor} from \"obsidian\";\r\n\r\nexport class OutputChannel_CurrentFileCaret extends OutputChannel_CurrentFile {\r\n    protected static readonly title = \"Current file: caret position\";\r\n\r\n    public static readonly hotkey_letter = \"R\";\r\n\r\n    /**\r\n     * Inserts text into the given editor, at caret position.\r\n     *\r\n     * @param editor\r\n     * @param output_message\r\n     * @protected\r\n     */\r\n    protected insertIntoEditor(editor: Editor, output_message: string): void {\r\n        editor.replaceSelection(output_message);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {OutputChannel_CurrentFile} from \"./OutputChannel_CurrentFile\";\r\nimport {Editor} from \"obsidian\";\r\n\r\nexport class OutputChannel_CurrentFileTop extends OutputChannel_CurrentFile {\r\n    protected static readonly title = \"Current file: top\";\r\n\r\n    public static readonly hotkey_letter = \"T\";\r\n\r\n    /**\r\n     * Inserts text into the given editor, at top.\r\n     *\r\n     * @param editor\r\n     * @param output_message\r\n     * @protected\r\n     */\r\n    protected insertIntoEditor(editor: Editor, output_message: string): void {\r\n        const top_position = editor.offsetToPos(0);\r\n        editor.replaceRange(output_message, top_position);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {OutputChannel} from \"./OutputChannel\";\r\nimport {EOL} from \"os\";\r\n\r\nexport class OutputChannel_StatusBar extends OutputChannel {\r\n    protected static readonly title = \"Status bar\";\r\n    protected static readonly accepts_empty_output = true;\r\n\r\n    public static readonly hotkey_letter = \"S\";\r\n\r\n    /**\r\n     * All received output cumulatively. Subsequent handlings will then use the whole output, not just new parts.\r\n     * Only used in \"realtime\" mode.\r\n     *\r\n     * @private\r\n     */\r\n    private realtimeContentBuffer = \"\";\r\n\r\n    /**\r\n     * Combine stdout and stderr (in case both of them happen to be present).\r\n     * @protected\r\n     */\r\n    protected static readonly combine_output_streams = EOL + EOL;\r\n\r\n    public async _handleBuffered(outputContent: string): Promise<void> {\r\n        this.setStatusBarContent(outputContent);\r\n    }\r\n\r\n    public async _handleRealtime(outputContent: string): Promise<void> {\r\n        this.realtimeContentBuffer += outputContent;\r\n        this.setStatusBarContent(this.realtimeContentBuffer);\r\n    }\r\n\r\n    private setStatusBarContent(outputContent: string) {\r\n        const status_bar_element = this.plugin.getOutputStatusBarElement();\r\n\r\n        outputContent = outputContent.trim();\r\n\r\n        // Full output (shown when hovering with mouse)\r\n        status_bar_element.setAttr(\"aria-label\", outputContent);\r\n\r\n        // Show last line permanently.\r\n        const output_message_lines = outputContent.split(/(\\r\\n|\\r|\\n)/u);\r\n        const last_output_line = output_message_lines[output_message_lines.length - 1];\r\n        status_bar_element.setText(last_output_line);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {OutputChannel_CurrentFile} from \"./OutputChannel_CurrentFile\";\r\nimport {Editor, EditorPosition} from \"obsidian\";\r\n\r\nexport class OutputChannel_CurrentFileBottom extends OutputChannel_CurrentFile {\r\n    protected static readonly title = \"Current file: bottom\";\r\n\r\n    public static readonly hotkey_letter = \"B\";\r\n\r\n    /**\r\n     * Inserts text into the given editor, at bottom.\r\n     *\r\n     * @param editor\r\n     * @param output_message\r\n     * @protected\r\n     */\r\n    protected insertIntoEditor(editor: Editor, output_message: string): void {\r\n        const bottom_position: EditorPosition = {\r\n            ch: editor.getLine(editor.lastLine()).length,   // The last character* of ...\r\n            line: editor.lastLine(),                        // ... the last line.\r\n        };                                                  // *) But do not subtract 1, because ch is zero-based, so when .length is used without -1, we are pointing AFTER the last character.\r\n        editor.replaceRange(output_message, bottom_position);\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {OutputChannel} from \"./OutputChannel\";\r\nimport {copyToClipboard} from \"../Common\";\r\nimport {EOL} from \"os\";\r\n\r\nexport class OutputChannel_Clipboard extends OutputChannel {\r\n    protected static readonly title = \"Clipboard\";\r\n\r\n    public static readonly hotkey_letter = \"L\";\r\n\r\n    /**\r\n     * All received output cumulatively. Subsequent handlings will then use the whole output, not just new parts.\r\n     * Only used in \"realtime\" mode.\r\n     *\r\n     * @private\r\n     */\r\n    private realtimeContentBuffer = \"\";\r\n\r\n    /**\r\n     * There can be both \"stdout\" and \"stderr\" present at the same time, or just one of them. If both are present, they\r\n     * will be joined together with \" \" as a separator.\r\n     * @protected\r\n     */\r\n    protected static readonly combine_output_streams = \" \"; // TODO: Change to \"\" as there should be no extra space between stdout and stderr. Compare it to the terminal: AFAIK there is no separation between stdout and stderr outputs, just that typically each output ends with a newline.\r\n\r\n    protected async _handleBuffered(outputContent: string): Promise<void> {\r\n        await copyToClipboard(outputContent);\r\n        this.notify(outputContent);\r\n    }\r\n\r\n    protected async _handleRealtime(outputContent: string): Promise<void> {\r\n        this.realtimeContentBuffer += outputContent;\r\n        await copyToClipboard(this.realtimeContentBuffer);\r\n        this.notify(this.realtimeContentBuffer);\r\n    }\r\n\r\n    private notify(output_message: string) {\r\n        if (this.plugin.settings.output_channel_clipboard_also_outputs_to_notification) {\r\n            // Notify the user so they know a) what was copied to clipboard, and b) that their command has finished execution.\r\n            this.plugin.newNotification(\"Copied to clipboard: \" + EOL + output_message + EOL + EOL + \"(Notification can be turned off in settings.)\");\r\n        }\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Hotkey, Modifier, Platform} from \"obsidian\";\r\nimport SC_Plugin from \"./main\";\r\nimport {debugLog} from \"./Debug\";\r\n\r\n/**\r\n * TODO: Move this to TShellCommand.\r\n */\r\nexport function getHotkeysForShellCommand(plugin: SC_Plugin, shell_command_id: string): Hotkey[] {\r\n    // Retrieve all hotkeys set by user.\r\n    // @ts-ignore\r\n    const app_custom_hotkeys = plugin.app.hotkeyManager?.customKeys;\r\n    if (!app_custom_hotkeys) {\r\n        debugLog(\"getHotkeysForShellCommand() failed, will return an empty array.\");\r\n        return [];\r\n    }\r\n\r\n    // Get only our hotkeys.\r\n    const hotkey_index = plugin.getPluginId() + \":\" + plugin.generateObsidianCommandId(shell_command_id); // E.g. \"obsidian-shellcommands:shell-command-0\"\r\n    debugLog(\"getHotkeysForShellCommand() succeeded.\");\r\n    return app_custom_hotkeys[hotkey_index] ?? []; // If no hotkey array is set for this command, return an empty array. Although I do believe that all commands do have an array anyway, but have this check just in case.\r\n}\r\n\r\n/**\r\n * TODO: Is there a way to make Obsidian do this conversion for us? Check this: https://github.com/pjeby/hotkey-helper/blob/c8a032e4c52bd9ce08cb909cec15d1ed9d0a3439/src/plugin.js#L4-L6\r\n *\r\n * @param hotkey\r\n * @constructor\r\n */\r\nexport function HotkeyToString(hotkey: Hotkey) {\r\n    const keys: string[] = [];\r\n    hotkey.modifiers.forEach((modifier: Modifier) => {\r\n        let modifier_key = modifier.toString(); // This is one of 'Mod' | 'Ctrl' | 'Meta' | 'Shift' | 'Alt'\r\n        if (\"Mod\" === modifier_key) {\r\n            // Change \"Mod\" to something more meaningful.\r\n            modifier_key = CmdOrCtrl(); // isMacOS should also be true if the device is iPhone/iPad. Can be handy if this plugin gets mobile support some day.\r\n        }\r\n        keys.push(modifier_key);\r\n    });\r\n    keys.push(hotkey.key); // This is something like a letter ('A', 'B' etc) or space/enter/whatever.\r\n    return keys.join(\" + \");\r\n}\r\n\r\nexport function CmdOrCtrl(): \"Cmd\" | \"Ctrl\" {\r\n    return Platform.isMacOS ? \"Cmd\" : \"Ctrl\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {OutputChannel} from \"./OutputChannel\";\r\nimport {\r\n    getOutputChannelClasses,\r\n    initializeOutputChannel,\r\n    OutputStreams,\r\n} from \"./OutputChannelFunctions\";\r\nimport {Setting, TextAreaComponent} from \"obsidian\";\r\nimport {OutputChannelCode, OutputStream} from \"./OutputChannelCode\";\r\nimport SC_Plugin from \"../main\";\r\nimport {ShellCommandParsingResult, TShellCommand} from \"../TShellCommand\";\r\nimport {SC_Modal} from \"../SC_Modal\";\r\nimport {getSelectionFromTextarea} from \"../Common\";\r\nimport {CmdOrCtrl} from \"../Hotkeys\";\r\nimport {EOL} from \"os\";\r\n\r\nexport class OutputChannel_Modal extends OutputChannel {\r\n    protected static readonly title = \"Ask after execution\";\r\n\r\n    private modal: OutputModal;\r\n\r\n    protected initialize(): void {\r\n        // Initialize a modal (but don't open yet)\r\n        this.modal = new OutputModal(\r\n            this.plugin,\r\n            this.t_shell_command,\r\n            this.shell_command_parsing_result,\r\n            this.processTerminator,\r\n        );\r\n    }\r\n\r\n    protected async _handleBuffered(outputs: OutputStreams, error_code: number | null): Promise<void> {\r\n        // Pass outputs to modal\r\n        this.modal.setOutputContents(outputs);\r\n\r\n        // Define a possible error code to be shown on the modal.\r\n        if (error_code !== null) {\r\n            this.modal.setExitCode(error_code);\r\n        }\r\n\r\n        // Done\r\n        this.modal.open();\r\n    }\r\n\r\n    protected async _handleRealtime(outputContent: string, outputStreamName: OutputStream): Promise<void> {\r\n        this.modal.addOutputContent(outputStreamName, outputContent);\r\n        if (!this.modal.isOpen()) {\r\n            this.modal.open();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @param exitCode Can be null if user terminated the process by clicking a button. In other places exitCode can be null if process is still running, but here that cannot be the case.\r\n     *\r\n     * @protected\r\n     */\r\n    protected _endRealtime(exitCode: number | null) {\r\n        // Delete terminator button as the process is already ended.\r\n        this.modal.removeProcessTerminatorButton();\r\n\r\n        // Pass exitCode to the modal\r\n        this.modal.setExitCode(exitCode);\r\n    }\r\n\r\n}\r\n\r\nclass OutputModal extends SC_Modal {\r\n\r\n    private readonly t_shell_command: TShellCommand;\r\n    private readonly shell_command_parsing_result: ShellCommandParsingResult;\r\n    private exit_code: number | null = null; // TODO: Think about changing the logic: exit code could be undefined when it's not received, and null when a user has terminated the execution. The change needs to be done in the whole plugin, although I only wrote about it in this OutputModal class.\r\n\r\n    // Fields and HTML elements\r\n    private outputFieldsContainer: HTMLElement;\r\n    private readonly outputFields: {[key: string]: Setting} = {};\r\n    private exitCodeElement: HTMLElement;\r\n    private processTerminatorButtonContainer: HTMLElement;\r\n\r\n    constructor(\r\n        plugin: SC_Plugin,\r\n        t_shell_command: TShellCommand,\r\n        shell_command_parsing_result: ShellCommandParsingResult,\r\n        private processTerminator: (() => void) | null,\r\n    ) {\r\n        super(plugin);\r\n\r\n        this.t_shell_command = t_shell_command;\r\n        this.shell_command_parsing_result = shell_command_parsing_result;\r\n\r\n        this.createOutputFields();\r\n    }\r\n\r\n    /**\r\n     * Called when doing \"buffered\" output handling.\r\n     *\r\n     * @param outputs\r\n     */\r\n    public setOutputContents(outputs: OutputStreams) {\r\n        Object.getOwnPropertyNames(outputs).forEach((outputStreamName: OutputStream) => {\r\n            const outputField: Setting = this.outputFields[outputStreamName];\r\n\r\n            // Set field value\r\n            const textareaComponent = outputField.components.first() as TextAreaComponent;\r\n            const outputContent = outputs[outputStreamName];\r\n            textareaComponent.setValue(outputContent as string); // as string = outputContent is not undefined because of the .forEach() loop.\r\n\r\n            // Make field visible (if it's not already)\r\n            outputField.settingEl.matchParent(\".SC-hide\")?.removeClass(\"SC-hide\");\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Called when doing \"realtime\" output handling.\r\n     *\r\n     * @param outputStreamName\r\n     * @param outputContent\r\n     */\r\n    public addOutputContent(outputStreamName: OutputStream, outputContent: string) {\r\n        const outputField: Setting = this.outputFields[outputStreamName];\r\n\r\n        // Update field value\r\n        const textareaComponent = outputField.components.first() as TextAreaComponent;\r\n        textareaComponent.setValue(textareaComponent.getValue() + outputContent);\r\n\r\n        // Make field visible (if it's not already)\r\n        outputField.settingEl.matchParent(\".SC-hide\")?.removeClass(\"SC-hide\");\r\n    }\r\n\r\n    public onOpen(): void {\r\n        super.onOpen();\r\n        this.modalEl.addClass(\"SC-modal-output\");\r\n\r\n        // Heading\r\n        const heading = this.shell_command_parsing_result.alias;\r\n        this.titleEl.innerText = heading ? heading : \"Shell command output\";  // TODO: Use this.setTitle() instead.\r\n\r\n        // Shell command preview\r\n        this.modalEl.createEl(\"pre\", {text: this.shell_command_parsing_result.shell_command, attr: {class: \"SC-no-margin SC-wrappable\"}}); // no margin so that exit code will be close.\r\n\r\n        // Container for terminating button and exit code\r\n        const processResultContainer = this.modalEl.createDiv();\r\n\r\n        // 'Request to terminate the process' icon button\r\n        if (this.processTerminator) {\r\n            this.processTerminatorButtonContainer = processResultContainer.createEl('span');\r\n            this.plugin.createRequestTerminatingButton(this.processTerminatorButtonContainer, this.processTerminator);\r\n        }\r\n\r\n        // Exit code (put on same line with process terminator button, if exists)\r\n        this.exitCodeElement = processResultContainer.createEl(\"small\", {text: \"Executing...\", attr: {style: \"font-weight: bold;\"}}); // Show \"Executing...\" before an actual exit code is received.\r\n        if (this.exit_code !== null) {\r\n            this.displayExitCode();\r\n        }\r\n\r\n        // Output fields\r\n        this.modalEl.insertAdjacentElement(\"beforeend\",this.outputFieldsContainer);\r\n\r\n        // Focus on the first output field\r\n        this.focusFirstField();\r\n\r\n        // A tip about selecting text.\r\n        this.modalEl.createDiv({\r\n            text: \"Tip! If you select something, only the selected text will be used.\",\r\n            attr: {class: \"setting-item-description\" /* A CSS class defined by Obsidian. */},\r\n        });\r\n    }\r\n\r\n    private createOutputFields() {\r\n        // Create a parent-less container. onOpen() will place it in the correct place.\r\n        this.outputFieldsContainer = document.createElement('div');\r\n\r\n        // Create field containers in correct order\r\n        let stdoutFieldContainer: HTMLDivElement;\r\n        let stderrFieldContainer: HTMLDivElement;\r\n        switch (this.t_shell_command.getOutputChannelOrder()) {\r\n            case \"stdout-first\": {\r\n                stdoutFieldContainer = this.outputFieldsContainer.createDiv();\r\n                stderrFieldContainer = this.outputFieldsContainer.createDiv();\r\n                break;\r\n            }\r\n            case \"stderr-first\": {\r\n                stderrFieldContainer = this.outputFieldsContainer.createDiv();\r\n                stdoutFieldContainer = this.outputFieldsContainer.createDiv();\r\n                break;\r\n            }\r\n        }\r\n\r\n        // Create fields\r\n        this.outputFields.stdout = this.createOutputField(\"stdout\", stdoutFieldContainer);\r\n        this.outputFields.stderr = this.createOutputField(\"stderr\", stderrFieldContainer);\r\n\r\n        // Hide the fields' containers at the beginning. They will be shown when content is added.\r\n        stdoutFieldContainer.addClass(\"SC-hide\");\r\n        stderrFieldContainer.addClass(\"SC-hide\");\r\n    }\r\n\r\n    private createOutputField(output_stream: OutputStream, containerElement: HTMLElement) {\r\n        let output_textarea: TextAreaComponent;\r\n\r\n        containerElement.createEl(\"hr\", {attr: {class: \"SC-no-margin\"}});\r\n\r\n        // Output stream name\r\n        new Setting(containerElement)\r\n            .setName(output_stream)\r\n            .setHeading()\r\n            .setClass(\"SC-no-bottom-border\")\r\n        ;\r\n\r\n        // Textarea\r\n        const textarea_setting = new Setting(containerElement)\r\n            .addTextArea(textarea => output_textarea = textarea)\r\n        ;\r\n        textarea_setting.infoEl.addClass(\"SC-hide\"); // Make room for the textarea by hiding the left column.\r\n        textarea_setting.settingEl.addClass(\"SC-output-channel-modal-textarea-container\", \"SC-no-top-border\");\r\n\r\n        // Add controls for redirecting the output to another channel.\r\n        const redirect_setting = new Setting(containerElement)\r\n            .setDesc(\"Redirect:\")\r\n            .setClass(\"SC-no-top-border\")\r\n            .setClass(\"SC-output-channel-modal-redirection-buttons-container\") // I think this calls actually HTMLDivElement.addClass(), so it should not override the previous .setClass().\r\n        ;\r\n        const outputChannels = getOutputChannelClasses();\r\n        Object.getOwnPropertyNames(outputChannels).forEach((output_channel_name: OutputChannelCode) => {\r\n            const outputChannelClass = outputChannels[output_channel_name];\r\n\r\n            // Ensure this channel is not excluded by checking that is has a hotkey defined.\r\n            if (outputChannelClass.hotkey_letter) {\r\n                // Ensure the output channel accepts this output stream. E.g. OutputChannel_OpenFiles does not accept \"stderr\".\r\n                if (outputChannelClass.acceptsOutputStream(output_stream)) {\r\n\r\n                    const textarea_element = textarea_setting.settingEl.find(\"textarea\") as HTMLTextAreaElement;\r\n\r\n                    // Define an output handler\r\n                    const handle_output = async () => {\r\n                        // Redirect output to the selected channel\r\n                        const output_streams: OutputStreams = {};\r\n                        output_streams[output_stream] =\r\n                            getSelectionFromTextarea(textarea_element, true) // Use the selection, or...\r\n                            ?? output_textarea.getValue() // ...use the whole text, if nothing is selected.\r\n                        ;\r\n                        const outputChannel = initializeOutputChannel(\r\n                            output_channel_name,\r\n                            this.plugin,\r\n                            this.t_shell_command,\r\n                            this.shell_command_parsing_result,\r\n                            \"buffered\", // Use \"buffered\" mode even if this modal was opened in \"realtime\" mode, because at this point the output redirection is a single-time job, not recurring.\r\n                            this.processTerminator,\r\n                        );\r\n                        await outputChannel.handleBuffered(output_streams, this.exit_code, false); // false: Disable output wrapping as it's already wrapped before the output content was passed to this modal.\r\n                    };\r\n\r\n                    // Create the button\r\n                    redirect_setting.addButton((button) => {\r\n                            button.onClick(async (event: MouseEvent) => {\r\n                                // Handle output\r\n                                await handle_output();\r\n\r\n                                // Finish\r\n                                if (event.ctrlKey) {\r\n                                    // Special click, control/command key is pressed.\r\n                                    // Close the modal.\r\n                                    this.close();\r\n                                } else {\r\n                                    // Normal click, control key is not pressed.\r\n                                    // Do not close the modal.\r\n                                    textarea_element.focus(); // Bring the focus back to the textarea in order to show a possible highlight (=selection) again.\r\n                                }\r\n                            });\r\n\r\n                            // Define button texts and assign hotkeys\r\n                            const output_channel_title: string = outputChannelClass.getTitle(output_stream);\r\n\r\n                            // Button text\r\n                            button.setButtonText(output_channel_title);\r\n\r\n                            // Tips about hotkeys\r\n                            button.setTooltip(\r\n                                `Redirect: Normal click OR ${CmdOrCtrl()} + ${outputChannelClass.hotkey_letter}.`\r\n                                + EOL + EOL +\r\n                                `Redirect and close the modal: ${CmdOrCtrl()} + click OR ${CmdOrCtrl()} + Shift + ${outputChannelClass.hotkey_letter}.`\r\n                            );\r\n                        },\r\n                    );\r\n\r\n                    // 1. hotkey: Ctrl/Cmd + number: handle output\r\n                    this.scope.register([\"Ctrl\"], outputChannelClass.hotkey_letter, handle_output);\r\n\r\n                    // 2. hotkey: Ctrl/Cmd + Shift + number: handle output and close the modal.\r\n                    this.scope.register([\"Ctrl\", \"Shift\"], outputChannelClass.hotkey_letter, () => {\r\n                        handle_output().then(); // then(): No need to wait for output handling to finish before closing the modal.\r\n                        this.close();\r\n                    });\r\n                }\r\n            }\r\n        });\r\n\r\n        return textarea_setting;\r\n    }\r\n\r\n    public removeProcessTerminatorButton() {\r\n        if (this.processTerminatorButtonContainer) {\r\n            this.processTerminatorButtonContainer.remove();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Should be called only if an exit code was received.\r\n     *\r\n     * @param exit_code Can be null if user terminated the process by clicking a button.\r\n     */\r\n    public setExitCode(exit_code: number | null) {\r\n        this.exit_code = exit_code;\r\n\r\n        // Try to show the exit code.\r\n        if (this.isOpen()) {\r\n            if (null === this.exit_code) {\r\n                // User has terminated the process, so there's no exit code even though the process has ended.\r\n                this.exitCodeElement.innerText = \"User terminated\";\r\n            } else {\r\n                // displayExistCode() can only be called if onOpen() has been called before.\r\n                // If onOpen() will be called later, it will call displayExitCode() itself when it sees that this.exit_code is defined.\r\n                this.displayExitCode();\r\n            }\r\n        }\r\n    }\r\n\r\n    private displayExitCode() {\r\n        if (null === this.exit_code) {\r\n            // Currently there are two callers for this method, and both of them does a null check on the exit code before'\r\n            // the call, so we'll never get here in practise.\r\n            // TODO: Remove this checking/throwing and make this method able to display three texts: a) an exit code, b) Executing..., or c) User terminated.\r\n            throw new Error(\"Cannot display exit code because it's null\");\r\n        }\r\n        this.exitCodeElement.innerText = \"Exit code: \" + this.exit_code.toString();\r\n    }\r\n\r\n    private focusFirstField() {\r\n        switch (this.t_shell_command.getOutputChannelOrder()) {\r\n            case \"stdout-first\": {\r\n                this.outputFields.stdout.controlEl.find(\"textarea\").focus();\r\n                break;\r\n            }\r\n            case \"stderr-first\": {\r\n                this.outputFields.stderr.controlEl.find(\"textarea\").focus();\r\n                break;\r\n            }\r\n        }\r\n    }\r\n\r\n    protected approve(): void {\r\n        // No need to perform any action, just close the modal.\r\n        this.close();\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {OutputChannel} from \"./OutputChannel\";\r\nimport {OutputStreams} from \"./OutputChannelFunctions\";\r\nimport {OutputStream} from \"./OutputChannelCode\";\r\nimport {\r\n    EditorSelectionOrCaret,\r\n    normalizePath,\r\n    PaneType,\r\n} from \"obsidian\";\r\nimport {\r\n    getEditor,\r\n    getVaultAbsolutePath,\r\n    isInteger,\r\n    isWindows,\r\n    prepareEditorPosition,\r\n} from \"../Common\";\r\nimport * as path from \"path\";\r\nimport {EOL} from \"os\";\r\nimport {debugLog} from \"../Debug\";\r\n\r\nexport class OutputChannel_OpenFiles extends OutputChannel {\r\n    protected static readonly title = \"Open files\";\r\n\r\n    public static readonly hotkey_letter = \"O\";\r\n\r\n    /**\r\n     * This output channel is not suitable for stderr, as stderr can contain unexpected messages.\r\n     * @protected\r\n     */\r\n    protected static readonly accepted_output_streams: OutputStream[] = [\"stdout\"];\r\n\r\n    protected _handleBuffered(output: OutputStreams, error_code: number | null): Promise<void> {\r\n        let handlingPipeline = Promise.resolve();\r\n        let output_stream_name: OutputStream;\r\n        for (output_stream_name in output) {\r\n            handlingPipeline = handlingPipeline.finally(() => {\r\n                return this.handle(output[output_stream_name] as string);\r\n            });\r\n        }\r\n        return handlingPipeline;\r\n    }\r\n\r\n    protected _handleRealtime(outputContent: string): Promise<void> {\r\n        return this.handle(outputContent);\r\n    }\r\n\r\n    private handle(outputContent: string): Promise<void> {\r\n        return new Promise<void>((resolve) => {\r\n            // Read file definitions. Usually there's just one, but there can be many. Definitions are separated by newline\r\n            // characters. Each file definition defines one file to be opened.\r\n            const file_definitions_string = outputContent.trim(); // Contains at least file name(s), and MAYBE: a caret position, new pane option, and view state\r\n            const file_definitions = file_definitions_string.split(/[\\r\\n]+/u);\r\n\r\n            // Iterate all file definitions that should be opened.\r\n            let opening_pipeline = Promise.resolve();\r\n            for (const file_definition of file_definitions) {\r\n                // Chain each file opening to happen one after another. If one file opening fails for whatever reason, it\r\n                // is ok to continue to open the next file. This is why .finally() is used instead of .then().\r\n                opening_pipeline = opening_pipeline.finally(() => {\r\n                    return this.interpretFileOpeningDefinition(file_definition);\r\n                });\r\n            }\r\n\r\n            opening_pipeline.finally(() => resolve() /* Tell that all openings have been processed. */);\r\n        });\r\n    }\r\n\r\n    private interpretFileOpeningDefinition(file_definition: string): Promise<void> {\r\n        return new Promise((resolve, reject) => {\r\n            debugLog(\"OutputChannel_OpenFiles: Interpreting file opening definition: \" + file_definition);\r\n            // Get parts that define different details about how the file should be opened\r\n            const file_definition_parts: string[] = file_definition.split(\":\"); // If file_definition is \"\", i.e. an empty string, the result will be [\"\"], i.e. an array with an empty string as its only item.\r\n\r\n            // The first part is always the file path\r\n            let open_file_path: string = file_definition_parts.shift() as string; // If file_definition is \"\", this will be \"\", too. 'as string' is used because file_definition_parts is never empty (it always contains at least one item), so .shift() will never return undefined here.\r\n\r\n            // On Windows: Check if an absolute path was split incorrectly. (E.g. a path starting with \"C:\\...\").\r\n            if (isWindows() && file_definition_parts.length > 0) {\r\n                const combined_path: string = open_file_path + \":\" + file_definition_parts[0];\r\n                if (path.isAbsolute(combined_path)) {\r\n                    // Yes, the first two parts do form an absolute path together, so they should not be split.\r\n                    open_file_path = combined_path;\r\n                    file_definition_parts.shift(); // Remove the second part so that it won't be accidentally processed in the 'Special features' part.\r\n                }\r\n            }\r\n\r\n            // Trim the file path, for being able to use cleaner separation between file name and other parts, e.g: MyFile.md : new-pane\r\n            open_file_path = open_file_path.trim();\r\n\r\n            // Special features\r\n            const caret_parts: number[] = []; // If caret position is present in file_definition_parts, the first item in this array will be the caret line, the second will be the column. If more parts are present, they will be used for making selections.\r\n            let newLeaf: PaneType | false = false;\r\n            let can_create_file = false;\r\n            let file_definition_interpreting_failed = false;\r\n\r\n            file_definition_parts.forEach((file_definition_part: string) => {\r\n                file_definition_part = file_definition_part.toLocaleLowerCase().trim(); // .trim() is for being able to use cleaner separation between e.g. different selections: MyFile.md:1:1:1:-1 : 5:1:5:-1\r\n\r\n                // Determine the part type\r\n                if (isInteger(file_definition_part, true)) {\r\n                    // This is a number, so consider it as a caret position part.\r\n                    caret_parts.push(parseInt(file_definition_part));\r\n                } else {\r\n                    const multipleNewPartsErrorMessage = \"Cannot open file: Only one of the following can be defined: new-pane, new-tab, or new-window.\";\r\n                    switch (file_definition_part) {\r\n                        case \"new-pane\":\r\n                            // Ensure no new-* definition is used before.\r\n                            if (newLeaf === false) {\r\n                                newLeaf = \"split\";\r\n                            } else {\r\n                                this.plugin.newError(multipleNewPartsErrorMessage);\r\n                                file_definition_interpreting_failed = true;\r\n                            }\r\n                            break;\r\n                        case \"new-tab\":\r\n                            // Ensure no new-* definition is used before.\r\n                            if (newLeaf === false) {\r\n                                newLeaf = \"tab\";\r\n                            } else {\r\n                                this.plugin.newError(multipleNewPartsErrorMessage);\r\n                                file_definition_interpreting_failed = true;\r\n                            }\r\n                            break;\r\n                        case \"new-window\":\r\n                            // Ensure no new-* definition is used before.\r\n                            if (newLeaf === false) {\r\n                                newLeaf = \"window\";\r\n                            } else {\r\n                                this.plugin.newError(multipleNewPartsErrorMessage);\r\n                                file_definition_interpreting_failed = true;\r\n                            }\r\n                            break;\r\n                        case \"can-create-file\":\r\n                            can_create_file = true;\r\n                            break;\r\n                        default:\r\n                            this.plugin.newError(\"Cannot open file: Unrecognised definition part: \" + file_definition_part + \" in \" + file_definition);\r\n                            file_definition_interpreting_failed = true;\r\n                    }\r\n                }\r\n            });\r\n            if (file_definition_interpreting_failed) {\r\n                reject();\r\n                return;\r\n            }\r\n\r\n            // Ensure the path is relative\r\n            if (path.isAbsolute(open_file_path)) {\r\n                // The path is absolute.\r\n                // Check if it can be converted to relative.\r\n                const vault_absolute_path: string = getVaultAbsolutePath(this.app);\r\n                if (open_file_path.toLocaleLowerCase().startsWith(vault_absolute_path.toLocaleLowerCase())) {\r\n                    // Converting to relative is possible\r\n                    open_file_path = open_file_path.substr(vault_absolute_path.length); // Get everything after the point where the vault path ends.\r\n                } else {\r\n                    // Cannot convert to relative, because the file does not reside in the vault\r\n                    this.plugin.newError(\"Cannot open file '\" + open_file_path + \"' as the path is outside this vault.\");\r\n                    reject();\r\n                    return;\r\n                }\r\n            }\r\n\r\n            // Clean up the file path\r\n            open_file_path = normalizePath(open_file_path); // normalizePath() is used on purpose, instead of normalizePath2(), because backslashes \\ should be converted to forward slashes /\r\n\r\n            this.openFileInTab(open_file_path, newLeaf, can_create_file).then(() => {\r\n                // The file is now open\r\n                // Check, did we have a caret position available. If not, do nothing.\r\n                const count_caret_parts: number = caret_parts.length;\r\n                if (count_caret_parts > 0) {\r\n                    // Yes, a caret position was defined in the output.\r\n\r\n                    // Ensure the correct amount of caret position parts.\r\n                    // 0 parts: no caret positioning needs to be done (but in this part of code the amount of parts is always greater than 0).\r\n                    // 1 part: caret line is defined, no column.\r\n                    // 2 parts: caret line and column are defined.\r\n                    // 3 parts: NOT ALLOWED.\r\n                    // 4 parts: selection starting position (line, column) and selection end position (line, column) are defined.\r\n                    // 5 parts or more: NOT ALLOWED. Exception: any number of sets of four parts is allowed, i.e. 8 parts, 12 parts, 16 parts etc. are allowed as they can define multiple selections.\r\n                    const error_message_base: string = \"File opened, but caret cannot be positioned due to an incorrect amount (\" + count_caret_parts + \") of numeric values in the output: \" + file_definition + EOL + EOL;\r\n                    if (count_caret_parts == 3) {\r\n                        // Incorrect amount of caret parts\r\n                        this.plugin.newError(error_message_base + \"Three numeric parts is an incorrect amount, correct would be 1,2 or 4 parts.\");\r\n                        reject();\r\n                        return;\r\n                    } else if (count_caret_parts > 4 && count_caret_parts % 4 !== 0) {\r\n                        // Incorrect amount of caret parts\r\n                        this.plugin.newError(error_message_base + \"Perhaps too many numeric parts are defined? If more than four parts are defined, make sure to define complete sets of four parts. The amount of numeric parts needs to be dividable by 4.\");\r\n                        reject();\r\n                        return;\r\n                    }\r\n\r\n                    // Even though the file is already loaded, rendering it may take some time, thus the height of the content may increase.\r\n                    // For this reason, there needs to be a tiny delay before setting the caret position. If the caret position is set immediately,\r\n                    // the caret will be placed in a correct position, but it might be that the editor does not scroll into correct position, so the\r\n                    // caret might be out of the view, even when it's in a correct place. (Obsidian version 0.13.23).\r\n                    window.setTimeout(() => {\r\n                        const editor = getEditor(this.app);\r\n                        if (editor) {\r\n                            if (count_caret_parts >= 4) {\r\n                                // Selection mode\r\n                                // There can be multiple selections defined\r\n                                const selections: EditorSelectionOrCaret[] = [];\r\n                                while (caret_parts.length) {\r\n                                    const fromLine: number | undefined = caret_parts.shift();\r\n                                    const fromColumn: number | undefined = caret_parts.shift();\r\n                                    const toLine: number | undefined = caret_parts.shift();\r\n                                    const toColumn: number | undefined = caret_parts.shift();\r\n                                    if (undefined === fromLine || undefined === fromColumn || undefined === toLine || undefined === toColumn) {\r\n                                        // This should never happen.\r\n                                        throw new Error(\"Encountered undefined values in fromLine, fromColumn, toLine, and/or toColumn. Strange, because the correct amount of parts in caret_parts was checked beforehand.\");\r\n                                    }\r\n                                    selections.push({\r\n                                        anchor: prepareEditorPosition(editor, fromLine, fromColumn),\r\n                                        head: prepareEditorPosition(editor, toLine, toColumn),\r\n                                    });\r\n                                }\r\n                                editor.setSelections(selections);\r\n                            } else {\r\n                                // Simple caret mode\r\n                                const caret_line: number = caret_parts[0];\r\n                                const caret_column: number = caret_parts[1] ?? 1;\r\n                                editor.setCursor(prepareEditorPosition(editor, caret_line, caret_column));\r\n                            }\r\n\r\n                            // After placing carets / selecting text, have a small delay after allowing to open another file (in case multiple files are opened in a row). This allows the selection to be remembered in the pane's history.\r\n                            window.setTimeout(resolve, 300); // If you change this ADDITIONAL delay, remember to change it in the documentation, too.\r\n                        } else {\r\n                            // No editor\r\n                            this.plugin.newError(\"File opened, but caret cannot be positioned because no editor was found.\");\r\n                            reject();\r\n                        }\r\n                    }, 500); // 500ms is probably long enough even if a new tab is opened (takes more time than opening a file into an existing tab). This can be made into a setting sometime. If you change this, remember to change it in the documentation, too.\r\n                } else {\r\n                    // No caret parts exist. All is done now.\r\n                    resolve();\r\n                }\r\n            }, (error_message: string | unknown) => {\r\n                if (typeof error_message === \"string\") {\r\n                    // Opening the file has failed.\r\n                    this.plugin.newError(error_message);\r\n                } else {\r\n                    // Some other runtime error has occurred.\r\n                    throw error_message;\r\n                }\r\n                reject();\r\n            });\r\n        });\r\n    }\r\n\r\n    private openFileInTab(file_path: string, newLeaf: PaneType | false, can_create_file: boolean): Promise<void> {\r\n        // Ensure that the file exists (or can be created)\r\n        const source_path = \"\"; // TODO: When adding an option for creating new files, read this documentation from Obsidian API's getNewFileParent(): \"sourcePath – The path to the current open/focused file, used when the user wants new files to be created “in the same folder”. Use an empty string if there is no active file.\"\r\n        const file_exists_or_can_be_created = can_create_file || null !== this.app.metadataCache.getFirstLinkpathDest(file_path, source_path);\r\n        if (file_exists_or_can_be_created) {\r\n            // Yes, the file exists (or can be created)\r\n            return this.app.workspace.openLinkText(file_path, source_path, newLeaf);\r\n        } else {\r\n            // No, the file does not exist, and it may not be created.\r\n            return Promise.reject(\"Cannot open file '\" + file_path + \"', as it does not exist. (If you want to allow file creation, add :can-create-file to the shell command output.)\");\r\n        }\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../main\";\r\nimport {OutputChannel_Notification} from \"./OutputChannel_Notification\";\r\nimport {OutputChannel, OutputChannels} from \"./OutputChannel\";\r\nimport {OutputChannel_CurrentFileCaret} from \"./OutputChannel_CurrentFileCaret\";\r\nimport {OutputChannel_CurrentFileTop} from \"./OutputChannel_CurrentFileTop\";\r\nimport {\r\n    OutputChannelCode,\r\n    OutputChannelCodes,\r\n    OutputHandlingMode,\r\n    OutputStream,\r\n} from \"./OutputChannelCode\";\r\nimport {OutputChannel_StatusBar} from \"./OutputChannel_StatusBar\";\r\nimport {OutputChannel_CurrentFileBottom} from \"./OutputChannel_CurrentFileBottom\";\r\nimport {OutputChannel_Clipboard} from \"./OutputChannel_Clipboard\";\r\nimport {ShellCommandParsingResult, TShellCommand} from \"../TShellCommand\";\r\nimport {OutputChannel_Modal} from \"./OutputChannel_Modal\";\r\nimport {OutputChannel_OpenFiles} from \"./OutputChannel_OpenFiles\";\r\n\r\nexport interface OutputStreams {\r\n    stdout?: string;\r\n    stderr?: string;\r\n}\r\n\r\nconst outputChannelClasses: {\r\n    [key: string]: typeof OutputChannel;\r\n} = {};\r\n\r\n// Register output channels\r\nregisterOutputChannel(\"notification\", OutputChannel_Notification);\r\nregisterOutputChannel(\"current-file-caret\", OutputChannel_CurrentFileCaret);\r\nregisterOutputChannel(\"current-file-top\", OutputChannel_CurrentFileTop);\r\nregisterOutputChannel(\"current-file-bottom\", OutputChannel_CurrentFileBottom);\r\nregisterOutputChannel(\"open-files\", OutputChannel_OpenFiles);\r\nregisterOutputChannel(\"status-bar\", OutputChannel_StatusBar);\r\nregisterOutputChannel(\"clipboard\", OutputChannel_Clipboard);\r\nregisterOutputChannel(\"modal\", OutputChannel_Modal);\r\n\r\n/**\r\n * This function is designed to be called after a 'Wait until finished' type of shell command finishes its execution.\r\n *\r\n * @param plugin\r\n * @param t_shell_command\r\n * @param shell_command_parsing_result\r\n * @param stdout\r\n * @param stderr\r\n * @param error_code TODO: Rename to exitCode everywhere in the codebase.\r\n * @param output_channels\r\n */\r\nexport function handleBufferedOutput(\r\n        plugin: SC_Plugin,\r\n        t_shell_command: TShellCommand,\r\n        shell_command_parsing_result: ShellCommandParsingResult,\r\n        stdout: string,\r\n        stderr: string,\r\n        error_code: number | null,\r\n        output_channels: OutputChannelCodes\r\n    ): void {\r\n    // Terminology: Stream = outputs stream from a command, can be \"stdout\" or \"stderr\". Channel = a method for this application to present the output ot user, e.g. \"notification\".\r\n\r\n    const shell_command_configuration = t_shell_command.getConfiguration(); // TODO: Refactor OutputChannels to use TShellCommand instead of the configuration objects directly.\r\n\r\n    // Insert stdout and stderr to an object in a correct order\r\n    let output: OutputStreams = {};\r\n    if (stdout.length && stderr.length) {\r\n        // Both stdout and stderr have content\r\n        // Decide the output order == Find out which data stream should be processed first, stdout or stderr.\r\n        switch (shell_command_configuration.output_channel_order) {\r\n            case \"stdout-first\":\r\n                output = {\r\n                    stdout: stdout,\r\n                    stderr: stderr,\r\n                };\r\n                break;\r\n            case \"stderr-first\":\r\n                output = {\r\n                    stderr: stderr,\r\n                    stdout: stdout,\r\n                };\r\n                break;\r\n        }\r\n    } else if (stdout.length) {\r\n        // Only stdout has content\r\n        output = {\r\n            stdout: stdout,\r\n        };\r\n    } else if (stderr.length) {\r\n        // Only stderr has content\r\n        output = {\r\n            stderr: stderr,\r\n        };\r\n    } else {\r\n        // Neither stdout nor stderr have content\r\n        // Provide empty output, some output channels will process it, while other will just ignore it.\r\n        output = {\r\n            \"stdout\": \"\",\r\n        };\r\n    }\r\n\r\n    // Should stderr be processed same time with stdout?\r\n    if (output_channels.stdout === output_channels.stderr) {\r\n        // Stdout and stderr use the same channel.\r\n        // Make one handling call.\r\n        handle_stream(\r\n            plugin,\r\n            t_shell_command,\r\n            shell_command_parsing_result,\r\n            output_channels.stdout,\r\n            output,\r\n            error_code,\r\n        );\r\n    } else {\r\n        // Stdout and stderr use different channels.\r\n        // Make two handling calls.\r\n        let output_stream_name: OutputStream;\r\n        for (output_stream_name in output) {\r\n            const output_channel_name = output_channels[output_stream_name];\r\n            const output_message = output[output_stream_name];\r\n            const separated_output: OutputStreams = {};\r\n            separated_output[output_stream_name] = output_message;\r\n            handle_stream(\r\n                plugin,\r\n                t_shell_command,\r\n                shell_command_parsing_result,\r\n                output_channel_name,\r\n                separated_output,\r\n                error_code,\r\n            );\r\n        }\r\n\r\n    }\r\n}\r\n\r\nasync function handle_stream(\r\n        plugin: SC_Plugin,\r\n        t_shell_command: TShellCommand,\r\n        shell_command_parsing_result: ShellCommandParsingResult,\r\n        output_channel_name: OutputChannelCode,\r\n        output: OutputStreams,\r\n        error_code: number|null\r\n    ): Promise<void> {\r\n\r\n    // Check if the output should be ignored\r\n    if (\"ignore\" !== output_channel_name) {\r\n        // The output should not be ignored.\r\n\r\n        // Check that an output channel class exists\r\n        if (undefined === outputChannelClasses[output_channel_name]) {\r\n            throw new Error(\"No output channel class found for channel '\" + output_channel_name + \"'.\");\r\n        }\r\n\r\n        // Instantiate the channel\r\n        const outputChannel: OutputChannel = initializeOutputChannel(\r\n            output_channel_name,\r\n            plugin,\r\n            t_shell_command,\r\n            shell_command_parsing_result,\r\n            \"buffered\",\r\n            null, // \"Buffered\" output handling does not use a terminator, as the process has already ended.\r\n        );\r\n\r\n        // Perform handling the output\r\n        await outputChannel.handleBuffered(output, error_code);\r\n    }\r\n}\r\n\r\nexport function startRealtimeOutputHandling(\r\n        plugin: SC_Plugin,\r\n        tShellCommand: TShellCommand,\r\n        shellCommandParsingResult: ShellCommandParsingResult,\r\n        outputChannelCodes: OutputChannelCodes,\r\n        processTerminator: (() => void) | null,\r\n    ): OutputChannels {\r\n\r\n    const outputChannels: OutputChannels = {};\r\n\r\n    // stdout\r\n    if (\"ignore\" !== outputChannelCodes.stdout) {\r\n        outputChannels.stdout = initializeOutputChannel(\r\n            outputChannelCodes.stdout,\r\n            plugin,\r\n            tShellCommand,\r\n            shellCommandParsingResult,\r\n            \"realtime\",\r\n            processTerminator,\r\n        );\r\n    }\r\n\r\n    // stderr\r\n    if (\"ignore\" !== outputChannelCodes.stderr) {\r\n        if (outputChannelCodes.stderr === outputChannelCodes.stdout) {\r\n            // stderr should use the same channel instance as stdout.\r\n            outputChannels.stderr = outputChannels.stdout;\r\n        } else {\r\n            // stderr uses a different channel than stdout.\r\n            outputChannels.stderr = initializeOutputChannel(\r\n                outputChannelCodes.stderr,\r\n                plugin,\r\n                tShellCommand,\r\n                shellCommandParsingResult,\r\n                \"realtime\",\r\n                processTerminator,\r\n            );\r\n        }\r\n    }\r\n\r\n    return outputChannels;\r\n}\r\n\r\nexport function getOutputChannelsOptionList(output_stream: OutputStream) {\r\n    const list: {\r\n        [key: string]: string;\r\n    } = {ignore: \"Ignore\"};\r\n    for (const name in outputChannelClasses) {\r\n        const channelClass: typeof OutputChannel = outputChannelClasses[name];\r\n        // Check that the stream is suitable for the channel\r\n        if (channelClass.acceptsOutputStream(output_stream)) {\r\n            list[name] = channelClass.getTitle(output_stream);\r\n        }\r\n    }\r\n    return list;\r\n}\r\n\r\nexport function getOutputChannelClasses() {\r\n    return outputChannelClasses;\r\n}\r\n\r\nexport function initializeOutputChannel(\r\n        channelCode: OutputChannelCode,\r\n        plugin: SC_Plugin,\r\n        tShellCommand: TShellCommand,\r\n        shellCommandParsingResult: ShellCommandParsingResult,\r\n        outputHandlingMode: OutputHandlingMode,\r\n        processTerminator: (() => void) | null,\r\n    ): OutputChannel {\r\n    // @ts-ignore TODO: Find out how to tell TypeScript that a subclass is being instatiated instead of the abstract base class:\r\n    return new outputChannelClasses[channelCode](\r\n        plugin,\r\n        tShellCommand,\r\n        shellCommandParsingResult,\r\n        outputHandlingMode,\r\n        processTerminator,\r\n    );\r\n}\r\n\r\nfunction registerOutputChannel(channelCode: OutputChannelCode, channelClass: typeof OutputChannel) {\r\n    if (undefined !== outputChannelClasses[channelCode]) {\r\n        throw new Error(\"OutputChannel named '\" + channelCode + \"' is already registered!\");\r\n    }\r\n    outputChannelClasses[channelCode] = channelClass;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {extractFileName, getOperatingSystem, isWindows} from \"./Common\";\r\n\r\nexport const PlatformShells = {\r\n    darwin: {\r\n        \"/bin/bash\": \"Bash\",\r\n        \"/bin/dash\": \"Dash\",\r\n        \"/bin/zsh\": \"Zsh (Z shell)\",\r\n    },\r\n    linux: {\r\n        \"/bin/bash\": \"Bash\",\r\n        \"/bin/dash\": \"Dash\",\r\n        \"/bin/zsh\": \"Zsh (Z shell)\",\r\n    },\r\n    win32: {\r\n        \"pwsh.exe\": \"PowerShell Core\",\r\n        \"PowerShell.exe\": \"PowerShell 5\",\r\n        \"CMD.EXE\": \"cmd.exe\",\r\n    },\r\n};\r\n\r\nexport function getUsersDefaultShell(): string {\r\n    if (isWindows()) {\r\n        if (undefined === process.env.ComSpec) {\r\n            throw new Error(\"process.env.ComSpec is not a string.\");\r\n        }\r\n        return process.env.ComSpec;\r\n    } else {\r\n        if (undefined === process.env.SHELL) {\r\n            throw new Error(\"process.env.SHELL is not a string.\");\r\n        }\r\n        return process.env.SHELL;\r\n    }\r\n}\r\n\r\nexport function isShellSupported(shell: string) {\r\n    const shell_file_name = extractFileName(shell);\r\n    const supported_shells = Object.getOwnPropertyNames(PlatformShells[getOperatingSystem()]);\r\n\r\n    // Linux and macOS: Add the ambiguous 'sh' as a supported shell. It's not present in PlatformShells, because it's\r\n    // not desired to be an explicitly selectable shell as it's uncertain, which shell it actually points to. But have\r\n    // it supported when it comes from the \"Use system default (sh)\" option.\r\n    if (!isWindows()) {\r\n        // The platform is either Linux or macOS.\r\n        // Add 'sh' support.\r\n        supported_shells.push(\"sh\");\r\n    }\r\n\r\n    for (const supported_shell_path of supported_shells) {\r\n        // Check that the shell file names match. It doesn't matter in which directory the shell is located in.\r\n        if (extractFileName(supported_shell_path).toLowerCase() === shell_file_name.toLowerCase()) {\r\n            // The shell can be considered to be supported.\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\n// SETTINGS AND DEFAULT VALUES\r\nimport {ShellCommandConfiguration} from \"./ShellCommandConfiguration\";\r\nimport SC_Plugin from \"../main\";\r\nimport {\r\n    CustomVariableConfiguration,\r\n    PromptConfiguration,\r\n} from \"../imports\";\r\nimport {OutputWrapperConfiguration} from \"../models/output_wrapper/OutputWrapper\";\r\nimport {\r\n    GlobalVariableDefaultValueConfiguration,\r\n} from \"../variables/Variable\";\r\n\r\nexport type SettingsVersionString = \"prior-to-0.7.0\" | string;\r\n\r\nexport interface SC_MainSettings {\r\n\r\n    // Common:\r\n    settings_version: SettingsVersionString;\r\n\r\n    // Hidden settings (no UI controls in the settings panel)\r\n    /**\r\n     * If true, logging stuff to console.log() will be enabled.\r\n     * Might also enable some testing {{variables}} in the future, perhaps.\r\n     */\r\n    debug: boolean;\r\n    obsidian_command_palette_prefix: string;\r\n\r\n    // Variables:\r\n    preview_variables_in_command_palette: boolean;\r\n    show_autocomplete_menu: boolean;\r\n\r\n    // Environments:\r\n    working_directory: string;\r\n    default_shells: IPlatformSpecificString;\r\n    environment_variable_path_augmentations: IPlatformSpecificString;\r\n\r\n    // Output:\r\n    error_message_duration: number;\r\n    notification_message_duration: number;\r\n    execution_notification_mode: ExecutionNotificationMode;\r\n    output_channel_clipboard_also_outputs_to_notification: boolean;\r\n\r\n    // Events:\r\n    enable_events: boolean;\r\n\r\n    // Modals:\r\n    approve_modals_by_pressing_enter_key: boolean;\r\n\r\n    // Shell commands:\r\n    /** If it's a number, limit the max height of a textarea. If it's false, don't limit at all. */\r\n    max_visible_lines_in_shell_command_fields: number | false;\r\n\r\n    /**\r\n     * Was before 0.15.0: An object where the key was an id and value was a ShellCommandConfiguration object.\r\n     * Now it's an array of ShellCommandConfiguration objects.\r\n     */\r\n    shell_commands: ShellCommandConfiguration[];\r\n\r\n    // Prompts:\r\n    prompts: PromptConfiguration[];\r\n\r\n    // Additional configuration for built-in variables. (Currently just global default values).\r\n    builtin_variables: {\r\n        [variableName: string]: {\r\n            default_value: GlobalVariableDefaultValueConfiguration | null,\r\n        }\r\n    };\r\n\r\n    // Custom variables\r\n    custom_variables: CustomVariableConfiguration[];\r\n\r\n    // Output wrappers\r\n    output_wrappers: OutputWrapperConfiguration[];\r\n\r\n    // Legacy:\r\n    /** @deprecated Use shell_commands object instead of this array. From now on, this array can be used only for migrating old configuration to shell_commands.*/\r\n    commands?: string[];\r\n}\r\n\r\nexport function getDefaultSettings(is_new_installation: boolean): SC_MainSettings {\r\n    return {\r\n        // Common:\r\n        settings_version: is_new_installation\r\n            ? SC_Plugin.SettingsVersion // For new installations, a specific settings version number can be used, as migrations do not need to be taken into account.\r\n            : \"prior-to-0.7.0\"  // This will be substituted by ShellCommandsPlugin.saveSettings() when the settings are saved.\r\n        ,\r\n\r\n        // Hidden settings (no UI controls in the settings panel)\r\n        debug: false,\r\n        obsidian_command_palette_prefix: \"Execute: \",\r\n\r\n        // Variables:\r\n        preview_variables_in_command_palette: true,\r\n        show_autocomplete_menu: true,\r\n\r\n        // Environments:\r\n        working_directory: \"\",\r\n        default_shells: {},\r\n        environment_variable_path_augmentations: {},\r\n\r\n        // Output:\r\n        error_message_duration: 20,\r\n        notification_message_duration: 10,\r\n        execution_notification_mode: \"disabled\",\r\n        output_channel_clipboard_also_outputs_to_notification: true,\r\n\r\n        // Events:\r\n        enable_events: true,\r\n\r\n        // Modals:\r\n        approve_modals_by_pressing_enter_key: true,\r\n\r\n        // Shell commands:\r\n        max_visible_lines_in_shell_command_fields: false, // No limit by default.\r\n        shell_commands: [],\r\n\r\n        // Prompts:\r\n        prompts: [],\r\n\r\n        // Additional configuration for built-in variables:\r\n        builtin_variables: {},\r\n\r\n        // Custom variables\r\n        custom_variables: [],\r\n\r\n        // Output wrappers\r\n        output_wrappers: [],\r\n    };\r\n}\r\n\r\n/**\r\n * All OSes supported by the Shell commands plugin.\r\n * Values are borrowed from NodeJS.Platform.\r\n * \"darwin\" = Macintosh.\r\n *\r\n * This type must be synchronous to IOperatingSystemSpecificString interface.\r\n *\r\n * @see NodeJS.Platform\r\n */\r\nexport type PlatformId = \"darwin\" | \"linux\" | \"win32\";\r\n\r\nexport const PlatformNames: IPlatformSpecificString = {\r\n    darwin: \"Macintosh\",\r\n    linux: \"Linux\",\r\n    win32: \"Windows\",\r\n};\r\n\r\n/**\r\n * All OSes supported by the Shell commands plugin.\r\n * Values are borrowed from NodeJS.Platform.\r\n *\r\n * This interface must be synchronous to OperatingSystemName type.\r\n *\r\n * @see NodeJS.Platform\r\n */\r\nexport interface IPlatformSpecificString {\r\n    /** This is Macintosh */\r\n    darwin?: string,\r\n    linux?: string,\r\n    win32?: string,\r\n}\r\n\r\nexport interface IPlatformSpecificStringWithDefault extends IPlatformSpecificString{\r\n    default: string,\r\n}\r\n\r\nexport type ICommandPaletteOptions = {\r\n    enabled: string;\r\n    unlisted: string;\r\n    disabled: string;\r\n}\r\n\r\nexport const CommandPaletteOptions: ICommandPaletteOptions = {\r\n    enabled: \"Command palette & hotkeys\",\r\n    unlisted: \"Hotkeys only\",\r\n    disabled: \"Excluded\",\r\n};\r\n\r\nexport type ExecutionNotificationMode = \"disabled\" | \"quick\" | \"permanent\" | \"if-long\";","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    ChildProcess,\r\n    spawn,\r\n    SpawnOptions,\r\n} from \"child_process\";\r\nimport {\r\n    cloneObject,\r\n    getOperatingSystem,\r\n    getVaultAbsolutePath,\r\n} from \"./Common\";\r\nimport * as path from \"path\";\r\nimport * as fs from \"fs\";\r\nimport {\r\n    handleBufferedOutput,\r\n    startRealtimeOutputHandling,\r\n} from \"./output_channels/OutputChannelFunctions\";\r\nimport {ShellCommandParsingProcess, ShellCommandParsingResult, TShellCommand} from \"./TShellCommand\";\r\nimport {isShellSupported} from \"./Shell\";\r\nimport {debugLog} from \"./Debug\";\r\nimport {SC_Event} from \"./events/SC_Event\";\r\nimport {\r\n    ConfirmationModal,\r\n    convertNewlinesToPATHSeparators,\r\n    getPATHEnvironmentVariableName,\r\n    getPATHSeparator,\r\n    Preaction,\r\n} from \"./imports\";\r\nimport SC_Plugin from \"./main\";\r\nimport {\r\n    ExecutionNotificationMode,\r\n    PlatformNames,\r\n} from \"./settings/SC_MainSettings\";\r\nimport {\r\n    OutputChannelCode,\r\n    OutputChannelCodes,\r\n    OutputStream,\r\n} from \"./output_channels/OutputChannelCode\";\r\nimport {Readable} from \"stream\";\r\nimport {Notice} from \"obsidian\";\r\nimport {OutputChannel} from \"./output_channels/OutputChannel\";\r\nimport {ParsingResult} from \"./variables/parseVariables\";\r\n\r\nexport class ShellCommandExecutor {\r\n\r\n    constructor(\r\n        private plugin: SC_Plugin,\r\n        private t_shell_command: TShellCommand,\r\n\r\n        /** Needed for Preactions to be able to access all variables, in case any variables are used by a Preaction. Use null, if the shell command execution happens outside of any event context. */\r\n        private sc_event: SC_Event | null,\r\n    ) {}\r\n\r\n    /**\r\n     * Performs preactions, and if they all give resolved Promises, executes the shell command.\r\n     */\r\n    public async doPreactionsAndExecuteShellCommand(parsing_process?: ShellCommandParsingProcess, overriding_output_channel?: OutputChannelCode) {\r\n        const preactions = this.t_shell_command.getPreactions();\r\n\r\n        // Does an already started ParsingProcess exist?\r\n        if (!parsing_process) {\r\n            // No ParsingProcess yet.\r\n            // Create one and parse all variables that are safe to parse before preactions.\r\n            debugLog(\"Going to prepare possible Preactions, but will first start a variable parsing process. Depending on possible Preactions, this might not yet parse all variables.\");\r\n            parsing_process = this.t_shell_command.createParsingProcess(this.sc_event);\r\n            // Parse the first set of variables, not all sets.\r\n            if (!await parsing_process.process()) {\r\n                // Some errors happened.\r\n                debugLog(\"Will not prepare possible Preactions, because the parsing process failed. Will cancel shell command execution.\");\r\n                parsing_process.displayErrorMessages();\r\n                return;\r\n            }\r\n        } else {\r\n            debugLog(\"Going to prepare possible Preactions with an already started variable parsing process.\");\r\n        }\r\n\r\n        // Create a pipeline for preactions.\r\n        let preaction_pipeline = Promise.resolve(true); // Will contain a series of preaction performs.\r\n\r\n        // Confirm execution from a user, if needed.\r\n        // I haven't decided yet if I want to move this to be its own Preaction subclass. Might make sense, but requires configuration migration.\r\n        if (this.t_shell_command.getConfiguration().confirm_execution) {\r\n            preaction_pipeline = preaction_pipeline.then(() => {\r\n                debugLog(\"Asking a confirmation from a user to execute shell command #\" + this.t_shell_command.getId());\r\n                return new Promise((resolve, reject) => {\r\n                    const confirmation_modal = new ConfirmationModal(\r\n                        this.plugin,\r\n                        this.t_shell_command.getAliasOrShellCommand(),\r\n                        \"Execute this shell command?\",\r\n                        \"Yes, execute\",\r\n                    );\r\n                    confirmation_modal.open();\r\n                    confirmation_modal.promise.then((execution_confirmed: boolean) => {\r\n                        if (execution_confirmed) {\r\n                            // The PromptModal has been closed.\r\n                            // Check if user wanted to execute the shell command or cancel.\r\n                            if (execution_confirmed) {\r\n                                // User wants to execute.\r\n                                debugLog(\"User confirmed to execute shell command #\" + this.t_shell_command.getId());\r\n                                resolve(true);\r\n                            } else {\r\n                                // User wants to cancel.\r\n                                debugLog(\"User cancelled execution of shell command #\" + this.t_shell_command.getId());\r\n                                resolve(false);\r\n                            }\r\n                        }\r\n                    });\r\n                });\r\n\r\n            });\r\n        }\r\n\r\n        // Perform preactions\r\n        preactions.forEach((preaction: Preaction) => {\r\n            debugLog(`Adding Preaction of type '${preaction.configuration.type}' to pipeline.`);\r\n            preaction_pipeline = preaction_pipeline.then(() => {\r\n                debugLog(`Calling Preaction of type '${preaction.configuration.type}'.`);\r\n                if (!parsing_process) {\r\n                    // Should have a ParsingProcess at this point.\r\n                    throw new Error(\"No parsing process. Cannot do preaction.\");\r\n                }\r\n                return preaction.perform(parsing_process, this.sc_event);\r\n            });\r\n        });\r\n        if (0 === preactions.length) {\r\n            debugLog(\"No Preactions to perform. This is ok.\");\r\n        }\r\n\r\n        preaction_pipeline.then(async (can_execute: boolean) => {\r\n            if (can_execute) {\r\n                // Parse either all variables, or if some variables are already parsed, then just the rest. Might also be that\r\n                // all variables are already parsed.\r\n                debugLog(\"Parsing all the rest of the variables (if there are any left).\");\r\n                if (!parsing_process) {\r\n                    // Should have a ParsingProcess at this point.\r\n                    throw new Error(\"No parsing process. Cannot execute shell command.\");\r\n                }\r\n                if (await parsing_process.processRest()) {\r\n                    // Parsing the rest of the variables succeeded\r\n                    // Execute the shell command.\r\n                    const parsing_results = parsing_process.getParsingResults();\r\n                    const shell_command_parsing_result: ShellCommandParsingResult = {\r\n                        shell_command: (parsing_results[\"shell_command\"] as ParsingResult).parsed_content as string,\r\n                        alias: (parsing_results[\"alias\"] as ParsingResult).parsed_content as string,\r\n                        environment_variable_path_augmentation: (parsing_results.environment_variable_path_augmentation as ParsingResult).parsed_content as string,\r\n                        stdinContent: parsing_results.stdinContent?.parsed_content as string,\r\n                        output_wrapper_stdout: parsing_results.output_wrapper_stdout?.parsed_content as string, // Output wrappers are not always present. If they are absent, use undefined.\r\n                        output_wrapper_stderr: parsing_results.output_wrapper_stderr?.parsed_content as string,\r\n                        succeeded: true,\r\n                        error_messages: [],\r\n                    };\r\n                    debugLog(\"Will call ShellCommandExecutor.executeShellCommand().\");\r\n                    this.executeShellCommand(shell_command_parsing_result, overriding_output_channel);\r\n                } else {\r\n                    // Parsing has failed.\r\n                    debugLog(\"Parsing the rest of the variables failed.\");\r\n                    parsing_process.displayErrorMessages();\r\n                }\r\n            } else {\r\n                // Cancel execution\r\n                debugLog(\"Shell command execution cancelled.\");\r\n            }\r\n        });\r\n\r\n\r\n    }\r\n\r\n    /**\r\n     * Does not ask for confirmation before execution. This should only be called if: a) a confirmation is already asked from a user, or b) this command is defined not to need a confirmation.\r\n     * Use confirmAndExecuteShellCommand() instead to have a confirmation asked before the execution.\r\n     *\r\n     * @param shell_command_parsing_result The actual shell command that will be executed is taken from this object's '.shell_command' property.\r\n     * @param overriding_output_channel Optional. If specified, all output streams will be directed to this output channel. Otherwise, output channels are determined from this.t_shell_command.\r\n     */\r\n    private executeShellCommand(shell_command_parsing_result: ShellCommandParsingResult, overriding_output_channel?: OutputChannelCode) {\r\n        const working_directory = this.getWorkingDirectory();\r\n\r\n        // Define output channels\r\n        let outputChannels = this.t_shell_command.getOutputChannels();\r\n        if (overriding_output_channel) {\r\n            // Ignore the shell command's normal channels and use temporarily something else.\r\n           outputChannels = {\r\n               'stdout': overriding_output_channel,\r\n               'stderr': overriding_output_channel,\r\n           };\r\n        }\r\n\r\n        // Check that the shell command is not empty\r\n        const shell_command = shell_command_parsing_result.shell_command.trim();\r\n        if (!shell_command.length) {\r\n            // It is empty\r\n            const error_message = this.getErrorMessageForEmptyShellCommand();\r\n            debugLog(error_message);\r\n            this.plugin.newError(error_message);\r\n            return;\r\n        }\r\n\r\n        // Check that the currently defined shell is supported by this plugin. If using system default shell, it's possible\r\n        // that the shell is something that is not supported. Also, the settings file can be edited manually, and incorrect\r\n        // shell can be written there.\r\n        const shell = this.t_shell_command.getShell();\r\n        if (!isShellSupported(shell)) {\r\n            debugLog(\"Shell is not supported: \" + shell);\r\n            this.plugin.newError(\"This plugin does not support the following shell: \" + shell);\r\n            return;\r\n        }\r\n\r\n        // Define an object for environment variables.\r\n        const environment_variables = cloneObject<typeof process.env>(process.env); // Need to clone process.env, otherwise the modifications below will be stored permanently until Obsidian is hard-restarted (= closed and launched again).\r\n\r\n        // Augment the PATH environment variable (if wanted)\r\n        const augmented_path = this.augmentPATHEnvironmentVariable(shell_command_parsing_result.environment_variable_path_augmentation);\r\n        if (augmented_path.length > 0) {\r\n            environment_variables[getPATHEnvironmentVariableName()] = augmented_path;\r\n        }\r\n\r\n        // Check that the working directory exists and is a folder\r\n        if (!fs.existsSync(working_directory)) {\r\n            // Working directory does not exist\r\n            // Prevent execution\r\n            debugLog(\"Working directory does not exist: \" + working_directory);\r\n            this.plugin.newError(\"Working directory does not exist: \" + working_directory);\r\n        }\r\n        else if (!fs.lstatSync(working_directory).isDirectory()) {\r\n            // Working directory is not a directory.\r\n            // Prevent execution\r\n            debugLog(\"Working directory exists but is not a folder: \" + working_directory);\r\n            this.plugin.newError(\"Working directory exists but is not a folder: \" + working_directory);\r\n        } else {\r\n            // Working directory is OK\r\n            // Prepare execution options\r\n            const options: SpawnOptions = {\r\n                \"cwd\": working_directory,\r\n                \"shell\": shell,\r\n                \"env\": environment_variables,\r\n            };\r\n\r\n            // Execute the shell command\r\n            debugLog(\"Executing command \" + shell_command + \" in \" + working_directory + \"...\");\r\n            try {\r\n                const child_process = spawn(shell_command, options);\r\n\r\n                // Pass stdin content (if defined)\r\n                if (undefined !== shell_command_parsing_result.stdinContent) {\r\n                    // Stdin content is defined\r\n                    debugLog(\"Stdin content is present in parsing result. Will write it to the process.\");\r\n                    if (null === child_process.stdin) {\r\n                        // noinspection ExceptionCaughtLocallyJS: The exception is caught locally below, but it's ok because it's then rethrown as the error message does not match '/spawn\\s+ENAMETOOLONG/i'.\r\n                        throw new Error(\"Shell command execution process does not have a standard input stream (stdin).\");\r\n                    }\r\n                    child_process.stdin.write(shell_command_parsing_result.stdinContent);\r\n                    child_process.stdin.end();\r\n                } else {\r\n                    debugLog(\"No stdin content is present in parsing result.\");\r\n                }\r\n\r\n                // Common error handling regardless of output handling mode\r\n                child_process.on(\"error\", (error: Error) => {\r\n                    // Probably most errors will NOT end up here, I guess this event occurs for some rare errors.\r\n                    //\r\n                    // A quote from https://nodejs.org/api/child_process.html#event-error (read 2022-10-29):\r\n                    // > The 'error' event is emitted whenever:\r\n                    // > - The process could not be spawned, or\r\n                    // > - The process could not be killed, or\r\n                    // > - Sending a message to the child process failed.\r\n\r\n                    debugLog(\"Shell command failed to execute: Received a non-stderr error message: \" + error.message);\r\n                    this.plugin.newError(\"Shell command failed to execute. Error: \" + error.message);\r\n                });\r\n\r\n                // Define output encoding\r\n                if (null === child_process.stdout || null == child_process.stderr) {\r\n                    // The exception is caught locally below, but it's ok because it's then rethrown as the error message does not match '/spawn\\s+ENAMETOOLONG/i'.\r\n                    throw new Error(\"Child process's stdout and/or stderr stream is null.\");\r\n                }\r\n                child_process.stdout.setEncoding(\"utf8\"); // Receive stdout and ...\r\n                child_process.stderr.setEncoding(\"utf8\"); // ... stderr as strings, not as Buffer objects.\r\n\r\n                // Define a terminator\r\n                const processTerminator = () => {\r\n                    child_process.kill(\"SIGTERM\");\r\n                };\r\n\r\n                // Hook into child_process for output handling\r\n                switch (this.t_shell_command.getOutputHandlingMode()) {\r\n                    case \"buffered\": {\r\n                        // Output will be buffered and handled as a single batch.\r\n                        this.handleBufferedOutput(child_process, shell_command_parsing_result, outputChannels);\r\n                        break;\r\n                    }\r\n\r\n                    case \"realtime\": {\r\n                        // Output will be handled on-the-go.\r\n                        this.handleRealtimeOutput(child_process, shell_command_parsing_result, outputChannels, processTerminator);\r\n                    }\r\n                }\r\n\r\n                // Display a notification of the execution (if wanted).\r\n                if (\"disabled\" !== this.plugin.settings.execution_notification_mode) {\r\n                    this.showExecutionNotification(child_process, shell_command, this.plugin.settings.execution_notification_mode, processTerminator);\r\n                }\r\n            } catch (exception) {\r\n                // An exception has happened.\r\n                // Check if the shell command was too long.\r\n                if (exception.message.match(/spawn\\s+ENAMETOOLONG/i)) {\r\n                    // It was too long. Show an error message.\r\n                    this.plugin.newError(\"Shell command execution failed because it's too long: \" + shell_command.length + \" characters. (Unfortunately the max limit is unknown).\");\r\n                } else {\r\n                    // The shell command was not too long, this exception is about something else.\r\n                    // Rethrow the exception.\r\n                    throw  exception;\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    private handleBufferedOutput(child_process: ChildProcess, shell_command_parsing_result: ShellCommandParsingResult, outputChannels: OutputChannelCodes) {\r\n        child_process.on(\"exit\", (exitCode: number | null) => {\r\n            // exitCode is null if user terminated the process. Reference: https://nodejs.org/api/child_process.html#event-exit (read on 2022-11-27).\r\n\r\n            // Get outputs\r\n            if (null === child_process.stdout || null == child_process.stderr) {\r\n                // The exception is caught locally below, but it's ok because it's then rethrown as the error message does not match '/spawn\\s+ENAMETOOLONG/i'.\r\n                throw new Error(\"Child process's stdout and/or stderr stream is null.\");\r\n            }\r\n            const stdout: string = child_process.stdout.read() ?? \"\";\r\n            let stderr: string = child_process.stderr.read() ?? \"\"; // let instead of const: stderr can be emptied later due to ignoring.\r\n\r\n            // Did the shell command execute successfully?\r\n            if (exitCode === null || exitCode > 0) {\r\n                // Some error occurred\r\n                debugLog(\"Command executed and failed. Error number: \" + exitCode + \". Stderr: \" + stderr);\r\n\r\n                // Check if this error should be displayed to the user or not\r\n                if (null !== exitCode && this.t_shell_command.getIgnoreErrorCodes().contains(exitCode)) {\r\n                    // The user has ignored this error.\r\n                    debugLog(\"User has ignored this error, so won't display it.\");\r\n\r\n                    // Handle only stdout output stream\r\n                    stderr = \"\";\r\n                    exitCode = null; // TODO: consider if exitCode should just be left untouched. It could be informative to 'Ask after execution' output channel that shows exit code to user.\r\n                } else {\r\n                    // The error can be shown.\r\n                    debugLog(\"Will display the error to user.\");\r\n                }\r\n\r\n                // Handle at least stdout (and maybe stderr) output stream\r\n                handleBufferedOutput(this.plugin, this.t_shell_command, shell_command_parsing_result, stdout, stderr, exitCode, outputChannels);\r\n            } else {\r\n                // Probably no errors, but do one more check.\r\n\r\n                // Even when 'error' is null and everything should be ok, there may still be error messages outputted in stderr.\r\n                if (stderr.length > 0) {\r\n                    // Check a special case: should error code 0 be ignored?\r\n                    if (this.t_shell_command.getIgnoreErrorCodes().contains(0)) {\r\n                        // Exit code 0 is on the ignore list, so suppress stderr output.\r\n                        stderr = \"\";\r\n                        debugLog(\"Shell command executed: Encountered error code 0, but stderr is ignored.\");\r\n                    } else {\r\n                        debugLog(\"Shell command executed: Encountered error code 0, and stderr will be relayed to an output handler.\");\r\n                    }\r\n                } else {\r\n                    debugLog(\"Shell command executed: No errors.\");\r\n                }\r\n\r\n                // Handle output\r\n                handleBufferedOutput(this.plugin, this.t_shell_command, shell_command_parsing_result, stdout, stderr, 0, outputChannels); // Use zero as an error code instead of null (0 means no error). If stderr happens to contain something, exit code 0 gets displayed in an error balloon (if that is selected as a channel for stderr).\r\n            }\r\n        });\r\n    }\r\n\r\n    private handleRealtimeOutput(\r\n            childProcess: ChildProcess,\r\n            shell_command_parsing_result: ShellCommandParsingResult,\r\n            outputChannelCodes: OutputChannelCodes,\r\n            processTerminator: (() => void) | null,\r\n        ) {\r\n\r\n        // Prepare output channels\r\n        const outputChannels = startRealtimeOutputHandling(\r\n            this.plugin,\r\n            this.t_shell_command,\r\n            shell_command_parsing_result,\r\n            outputChannelCodes,\r\n            processTerminator,\r\n        );\r\n\r\n        // Define an output handler\r\n        const handleNewOutputContent = async (outputStreamName: OutputStream, readableStream: Readable) => {\r\n            if (null === childProcess.stdout || null == childProcess.stderr) {\r\n                throw new Error(\"Child process's stdout and/or stderr stream is null.\");\r\n            }\r\n\r\n            // Don't emit new events while the current handling is in progress. (I think) it might cause a race condition where a simultaneous handling could overwrite another handling's data. Pause both streams, not just the current one, to maintain correct handling order also between the two streams.\r\n            childProcess.stdout.pause();\r\n            childProcess.stderr.pause();\r\n\r\n            const outputContent = readableStream.read() ?? \"\";\r\n            const outputChannel: OutputChannel | undefined = outputChannels[outputStreamName];\r\n            if (undefined === outputChannel) {\r\n                throw new Error(\"Output channel is undefined.\");\r\n            }\r\n            await outputChannel.handleRealtime(outputStreamName, outputContent);\r\n\r\n            // Can emit new events again.\r\n            childProcess.stdout.resume();\r\n            childProcess.stderr.resume();\r\n        };\r\n\r\n        // Hook into output streams' (such as stdout and stderr) output retrieving events.\r\n        // Note that there might be just one stream, e.g. only stderr, if stdout is ignored. In the future, there might also be more than two streams, when custom streams are implemented.\r\n        for (const outputStreamName of Object.getOwnPropertyNames(outputChannels) as OutputStream[]) {\r\n            const readableStream: Readable | null = childProcess[outputStreamName];\r\n            if (null === readableStream) {\r\n                throw new Error(\"Child process's readable stream '\"+outputStreamName+\"' is null.\");\r\n            }\r\n            readableStream.on(\r\n                \"readable\",\r\n                () => handleNewOutputContent(outputStreamName, readableStream),\r\n            );\r\n        }\r\n\r\n        // Hook into exit events\r\n        childProcess.on(\"exit\", (exitCode: number, signal: string /* TODO: Pass signal to channels so it can be shown to users in the future */) => {\r\n            // Call all OutputChannels' endRealtime().\r\n            const alreadyCalledChannelCodes: OutputChannelCode[] = [];\r\n            for (const outputStreamName of Object.getOwnPropertyNames(outputChannels) as OutputStream[]) {\r\n                const outputChannel: OutputChannel | undefined = outputChannels[outputStreamName];\r\n                if (undefined === outputChannel) {\r\n                    throw new Error(\"Output channel is undefined.\");\r\n                }\r\n                const outputChannelCode: OutputChannelCode = outputChannelCodes[outputStreamName];\r\n\r\n                // Ensure this OutputChannel has not yet been called.\r\n                if (!alreadyCalledChannelCodes.includes(outputChannelCode)) {\r\n                    // Not yet called, so do the call.\r\n                    outputChannel.endRealtime(exitCode);\r\n\r\n                    // Mark that this channel's endRealtime() has already been called. Solves a situation where stderr and stdout uses the same channel, in which case endRealtime() should not be accidentally called twice.\r\n                    alreadyCalledChannelCodes.push(outputChannelCode);\r\n                }\r\n            }\r\n        });\r\n    }\r\n\r\n    private getWorkingDirectory() {\r\n        // Returns either a user defined working directory, or an automatically detected one.\r\n        const working_directory = this.plugin.settings.working_directory;\r\n        if (working_directory.length == 0) {\r\n            // No working directory specified, so use the vault directory.\r\n            return getVaultAbsolutePath(this.plugin.app);\r\n        } else if (!path.isAbsolute(working_directory)) {\r\n            // The working directory is relative.\r\n            // Help to make it refer to the vault's directory. Without this, the relative path would refer to Obsidian's installation directory (at least on Windows).\r\n            return path.join(getVaultAbsolutePath(this.plugin.app), working_directory);\r\n        }\r\n        return working_directory;\r\n    }\r\n\r\n    private augmentPATHEnvironmentVariable(path_augmentation: string): string {\r\n        path_augmentation = convertNewlinesToPATHSeparators(path_augmentation, getOperatingSystem());\r\n        // Check if there's anything to augment.\r\n        if (path_augmentation.length > 0) {\r\n            // Augment.\r\n            const original_path: string | undefined = process.env[getPATHEnvironmentVariableName()];\r\n            if (undefined === original_path) {\r\n                throw new Error(\"process.env does not contain '\" + getPATHEnvironmentVariableName() + \"'.\");\r\n            }\r\n            let augmented_path: string;\r\n            if (path_augmentation.contains(original_path)) {\r\n                // The augmentation contains the original PATH.\r\n                // Simply replace the whole original PATH with the augmented one, as there's no need to care about including\r\n                // the original content.\r\n                debugLog(\"Augmenting environment variable PATH so it will become \" + path_augmentation);\r\n                augmented_path = path_augmentation;\r\n            } else {\r\n                // The augmentation does not contain the original PATH.\r\n                // Instead of simply replacing the original PATH, append the augmentation after it.\r\n                const separator = getPATHSeparator(getOperatingSystem());\r\n                debugLog(\"Augmenting environment variable PATH by adding \" + separator + path_augmentation + \" after it.\");\r\n                augmented_path = original_path + separator + path_augmentation;\r\n            }\r\n            debugLog(\"PATH augmentation result: \" + augmented_path);\r\n            return augmented_path;\r\n        } else {\r\n            // No augmenting is needed.\r\n            debugLog(\"No augmentation is defined for environment variable PATH. This is completely ok.\");\r\n            return \"\";\r\n        }\r\n    }\r\n\r\n    /**\r\n     * This method should only be called if it's first checked that neither shell command version for the current platform nor a 'default' version exists.\r\n     *\r\n     * @private\r\n     */\r\n    private getErrorMessageForEmptyShellCommand(): string {\r\n        if (this.t_shell_command.getNonEmptyPlatformIds().length > 0) {\r\n            // The shell command contains versions for other platforms, but not for the current one.\r\n            const current_platform_name = PlatformNames[getOperatingSystem()];\r\n            const version_word = this.t_shell_command.getNonEmptyPlatformIds().length > 1 ? \"versions\" : \"a version\";\r\n            const other_platform_names = this.t_shell_command.getNonEmptyPlatformIds().map(platform_id => PlatformNames[platform_id]).join(\" and \");\r\n            return `The shell command does not have a version for ${current_platform_name}, it only has ${version_word} for ${other_platform_names}.`;\r\n        } else {\r\n            // The shell command doesn't contain a version for any platforms, it's completely empty.\r\n            return \"The shell command is empty. :(\";\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Displays a notification balloon indicating a user that a shell command is being executed.\r\n     *\r\n     * @param child_process\r\n     * @param shell_command\r\n     * @param execution_notification_mode\r\n     * @param processTerminator Will be called if user clicks 'Request to terminate the process' icon.\r\n     * @private\r\n     */\r\n    private showExecutionNotification(\r\n        child_process: ChildProcess,\r\n        shell_command: string,\r\n        execution_notification_mode: ExecutionNotificationMode,\r\n        processTerminator: () => void,\r\n    ) {\r\n        const createRequestTerminatingButton = (notice: Notice) => {\r\n            // @ts-ignore Notice.noticeEl belongs to Obsidian's PRIVATE API, and it may change without a prior notice. Only\r\n            // create the button if noticeEl exists and is an HTMLElement.\r\n            const noticeEl = notice.noticeEl;\r\n            if (undefined !== noticeEl && noticeEl instanceof HTMLElement) {\r\n                this.plugin.createRequestTerminatingButton(noticeEl, processTerminator);\r\n            }\r\n        };\r\n\r\n        const execution_notification_message = \"Executing: \" + (this.t_shell_command.getAlias() || shell_command);\r\n        switch (execution_notification_mode) {\r\n            case \"quick\": {\r\n                // Retrieve the timeout from settings defined by a user.\r\n                const processNotification = this.plugin.newNotification(execution_notification_message, undefined);\r\n                createRequestTerminatingButton(processNotification);\r\n                break;\r\n            }\r\n            case \"permanent\": {\r\n                // Show the notification until the process ends.\r\n                const processNotification = this.plugin.newNotification(execution_notification_message, 0);\r\n                createRequestTerminatingButton(processNotification);\r\n\r\n                // Hide the notification when the process finishes.\r\n                child_process.on(\"exit\", () => processNotification.hide());\r\n                break;\r\n            }\r\n            case \"if-long\": {\r\n                // Only show the notification if the process runs for an extended period of time (defined below).\r\n                window.setTimeout(() => {\r\n                    // Check if the process is still running.\r\n                    if (null === child_process.exitCode && !child_process.killed) {\r\n                        // The process is still running.\r\n                        // Display notification.\r\n                        const processNotification = this.plugin.newNotification(execution_notification_message, 0);\r\n                        createRequestTerminatingButton(processNotification);\r\n\r\n                        // Hide the notification when the process finishes.\r\n                        child_process.on(\"exit\", () => processNotification.hide());\r\n                    }\r\n                }, 2000); // If you change the timeout, change documentation, too!\r\n                break;\r\n            }\r\n        }\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {debugLog} from \"../Debug\";\r\nimport {\r\n    Model\r\n} from \"../imports\";\r\n\r\nexport abstract class Instance {\r\n\r\n    /**\r\n     * Configuration of the parent instance. E.g. if the current instance is a PromptField, then parent_configurations is a Prompt's configuration.\r\n     * Can be trusted to always exist, unlike parent_instance.\r\n     */\r\n    public parent_configuration: InstanceConfiguration;\r\n\r\n    /**\r\n     * E.g. if the current instance is a PromptField, then parent_instance is a Prompt.\r\n     * Only present for instances whose parent is something else than the root settings object.\r\n     */\r\n    public parent_instance: Instance | null;\r\n\r\n    public constructor(\r\n        public readonly model: Model,\r\n        public readonly configuration: InstanceConfiguration,\r\n        parent_instance_or_configuration: Instance | InstanceConfiguration,\r\n    ) {\r\n        debugLog(this.constructor.name + \": Creating a new instance.\");\r\n\r\n        // Determine parent type\r\n        if (parent_instance_or_configuration instanceof Instance) {\r\n            // It's an instance object\r\n            this.parent_instance = parent_instance_or_configuration;\r\n            this.parent_configuration = this.parent_instance.configuration;\r\n        } else {\r\n            // It's a configuration object.\r\n            // No parent instance is available, so probably this is about SC_MainSettings object, as it does not have Model/Instance classes (at least yet).\r\n            this.parent_instance = null; // It's null already, but do this just to make a statement.\r\n            this.parent_configuration = parent_instance_or_configuration;\r\n        }\r\n    }\r\n\r\n    public abstract getTitle(): string;\r\n\r\n    public setIfValid(field: string, value: unknown): Promise<void> {\r\n        return this.model.validateValue(this, field, value).then(() => {\r\n            this.configuration[field] = value;\r\n        });\r\n    }\r\n\r\n}\r\n\r\nexport interface InstanceConfiguration {\r\n    [key: string]: any;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../main\";\r\nimport {Setting} from \"obsidian\";\r\nimport {debugLog} from \"../Debug\";\r\nimport {\r\n    ConfirmationModal,\r\n    Instance,\r\n    InstanceConfiguration,\r\n} from \"../imports\";\r\n\r\nexport abstract class Model {\r\n\r\n    public constructor(\r\n        public readonly plugin: SC_Plugin,\r\n    ) {}\r\n\r\n    public abstract getSingularName(): string;\r\n\r\n    /**\r\n     *TODO: Change this to public and call it from Instance.constructor() and store the result in a new property Instance.parent_relation. Make other callers use the new property instead of calling this method.\r\n     */\r\n    protected abstract defineParentConfigurationRelation(instance: Instance): ParentModelOneToOneRelation | ParentModelOneToManyIndexRelation | ParentModelOneToManyIdRelation;\r\n\r\n    /**\r\n     * Creates instance objects from already existing configuration. I.e. does not create NEW instances or new configurations.\r\n     */\r\n    public abstract loadInstances(parent_instance_or_configuration: Instance | InstanceConfiguration): Set<Instance> | Map<string, Instance>;\r\n\r\n    /**\r\n     * Creates a new instance and adds its configuration to the parent configuration.\r\n     */\r\n    public abstract newInstance(parent_instance_or_configuration: Instance | InstanceConfiguration): Instance;\r\n\r\n    public abstract getDefaultConfiguration(): InstanceConfiguration;\r\n\r\n    public createSettingFields(instance: Instance, parent_element: HTMLElement, with_deletion = true) {\r\n        debugLog(this.constructor.name + \": Creating setting fields.\");\r\n\r\n        // Create a container\r\n        const setting_fields_container = parent_element.createDiv(); // Create a nested container that can be easily deleted if the instance is deleted.\r\n\r\n        const main_setting_field = this._createSettingFields(instance, setting_fields_container);\r\n        if (with_deletion) {\r\n            main_setting_field.addExtraButton(button => button\r\n                .setIcon(\"trash\")\r\n                .setTooltip(\"Delete this \" + this.getSingularName().toLocaleLowerCase())\r\n                .onClick(() => {\r\n                    // The trash icon has been clicked\r\n                    // Open up a modal asking for confirmation if the instance can be deleted from this.parent_configuration.\r\n                    const confirmation_modal = new ConfirmationModal(\r\n                        this.plugin,\r\n                        \"Delete \" + this.getSingularName().toLocaleLowerCase() + \": \" + instance.getTitle(),\r\n                        \"Are you sure you want to delete this \" + this.getSingularName().toLocaleLowerCase() + \"?\",\r\n                        \"Yes, delete\",\r\n                    );\r\n                    confirmation_modal.open();\r\n                    confirmation_modal.promise.then(async (deletion_confirmed: boolean) => {\r\n                        if (deletion_confirmed) {\r\n                            // User has confirmed the deletion.\r\n                            // Delete the configuration and remove the instance from custom collections.\r\n                            this.deleteInstance(instance);\r\n\r\n                            // Delete setting fields.\r\n                            setting_fields_container.remove();\r\n\r\n                            // Save settings\r\n                            await this.plugin.saveSettings();\r\n                        }\r\n                    });\r\n                }),\r\n            );\r\n        }\r\n        return main_setting_field;\r\n    }\r\n\r\n    /**\r\n     * Creates setting fields into the given container_element, and then returns the main Setting that\r\n     * can be used for injecting a deleting button into.\r\n     *\r\n     * @param instance\r\n     * @param container_element\r\n     * @protected\r\n     */\r\n    protected abstract _createSettingFields(instance: Instance, container_element: HTMLElement): Setting;\r\n\r\n    /**\r\n     * Deletes the instance from configuration, and calls _deleteChild() which will delete the instance from custom collections.\r\n     *\r\n     * Can be made public if needed.\r\n     */\r\n    public deleteInstance(instance: Instance) {\r\n        debugLog(this.constructor.name + \": Deleting an instance.\");\r\n        this._deleteInstance(instance);\r\n        const relation = this.defineParentConfigurationRelation(instance);\r\n        switch (relation.type) {\r\n            // case \"one-to-one\": // TODO: Uncomment when first model that needs this is implemented.\r\n                // This is a relation where 'key' points directly to the instance's configuration.\r\n                // delete this.parent_configuration[this.relation.key];\r\n                // break;\r\n            case \"one-to-many-index\": {\r\n                // This is a relation where 'key' points to an indexed array of instance configurations. Use 'index' to pick the correct instance configuration.\r\n                instance.parent_configuration[relation.key].splice(relation.index, 1); // Do not use delete, as it would place null in the list.\r\n                break;\r\n            } case \"one-to-many-id\": {\r\n                // This is a relation where 'key' points to an indexed array of instance configurations. Use 'id' to determine the correct index.\r\n                const index = this.idToIndex(instance.parent_configuration[relation.key], relation.id);\r\n                if (null === index) {\r\n                    // Something went wrong\r\n                    throw new Error(`${this.constructor.name}.deleteInstance(): Could not find an index for id ${relation.id}.`);\r\n                }\r\n                instance.parent_configuration[relation.key].splice(index, 1); // Do not use delete, as it would place null in the list.\r\n                break;\r\n\t\t\t}\r\n        }\r\n    }\r\n\r\n    private idToIndex(configurations: InstanceConfiguration[], id: string): number | null {\r\n        let result_index = null;\r\n        configurations.forEach((instance_configuration: InstanceConfiguration, index) => {\r\n            if (instance_configuration.id === id) {\r\n                // This is the correct configuration.\r\n                result_index = index;\r\n            }\r\n        });\r\n        return result_index;\r\n    }\r\n\r\n    /**\r\n     * This should delete the instance from custom collections. It should be overridden by all Instance classes that have deletable children.\r\n     */\r\n    protected _deleteInstance(instance: Instance) {\r\n        throw new Error(this.constructor.name + \".deleteInstance(): This class does not override _deleteInstance() method. Maybe the class is not supposed to have children?\");\r\n    }\r\n\r\n    public abstract validateValue(instance: Instance, field: string, value: unknown): Promise<void>;\r\n\r\n}\r\n\r\n/**\r\n * @abstract This interface should not be used directly. Use one of the child interfaces instead.\r\n */\r\ninterface ParentModelRelation {\r\n    type: \"one-to-one\" | \"one-to-many-index\" | \"one-to-many-id\";\r\n    key: string;\r\n}\r\n\r\nexport interface ParentModelOneToOneRelation extends ParentModelRelation {\r\n    type: \"one-to-one\";\r\n}\r\n\r\nexport interface ParentModelOneToManyIndexRelation extends ParentModelRelation {\r\n    type: \"one-to-many-index\";\r\n    index: number; // TODO: Find a way to use something like: keyof InstanceConfiguration[this[\"key\"]] . 'keyof' needs to be replaced with something suitable for a numeric index of an array. 'keyof' is only applicable for objects.\r\n}\r\n\r\nexport interface ParentModelOneToManyIdRelation extends ParentModelRelation {\r\n    type: \"one-to-many-id\";\r\n    id: string;\r\n}\r\n\r\n\r\n// Model class collection\r\n\r\nconst model_classes: Map<string, Model> = new Map();\r\n\r\nexport function introduceModelClass(model_class: Model) {\r\n    model_classes.set(model_class.constructor.name, model_class);\r\n}\r\n\r\nexport function getModel<ModelClass>(model_class_name: string): ModelClass  {\r\n    return model_classes.get(model_class_name) as unknown as ModelClass;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Instance} from \"../Instance\";\r\nimport SC_Plugin from \"../../main\";\r\nimport {SC_MainSettings} from \"../../settings/SC_MainSettings\";\r\nimport {getIDGenerator} from \"../../IDGenerator\";\r\nimport {OutputWrapperModel} from \"./OutputWrapperModel\";\r\n\r\nexport class OutputWrapper extends Instance {\r\n\r\n    constructor(\r\n        public model: OutputWrapperModel,\r\n        protected plugin: SC_Plugin,\r\n        public configuration: OutputWrapperConfiguration,\r\n        public parent_configuration: SC_MainSettings,\r\n    ) {\r\n        super(model, configuration, parent_configuration);\r\n\r\n        // Introduce the ID to an ID generator so that it won't accidentally generate the same ID again when creating new OutputWrappers.\r\n        getIDGenerator().addReservedID(configuration.id);\r\n    }\r\n\r\n    public getID() {\r\n        return this.configuration.id;\r\n    }\r\n\r\n    public getTitle() {\r\n        return this.configuration.title;\r\n    }\r\n\r\n    public getContent() {\r\n        return this.configuration.content;\r\n    }\r\n\r\n    public getConfiguration() {\r\n        return this.configuration;\r\n    }\r\n}\r\n\r\nexport interface OutputWrapperConfiguration {\r\n    id: string;\r\n    title: string;\r\n    content: string;\r\n}","(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.autocomplete = factory());\n}(this, (function () { 'use strict';\n\n  /*\r\n   * https://github.com/kraaden/autocomplete\r\n   * Copyright (c) 2016 Denys Krasnoshchok\r\n   * MIT License\r\n   */\r\n  function autocomplete(settings) {\r\n      // just an alias to minimize JS file size\r\n      var doc = document;\r\n      var container = settings.container || doc.createElement(\"div\");\r\n      var containerStyle = container.style;\r\n      var userAgent = navigator.userAgent;\r\n      var mobileFirefox = ~userAgent.indexOf(\"Firefox\") && ~userAgent.indexOf(\"Mobile\");\r\n      var debounceWaitMs = settings.debounceWaitMs || 0;\r\n      var preventSubmit = settings.preventSubmit || false;\r\n      var disableAutoSelect = settings.disableAutoSelect || false;\r\n      // 'keyup' event will not be fired on Mobile Firefox, so we have to use 'input' event instead\r\n      var keyUpEventName = mobileFirefox ? \"input\" : \"keyup\";\r\n      var items = [];\r\n      var inputValue = \"\";\r\n      var minLen = 2;\r\n      var showOnFocus = settings.showOnFocus;\r\n      var selected;\r\n      var keypressCounter = 0;\r\n      var debounceTimer;\r\n      if (settings.minLength !== undefined) {\r\n          minLen = settings.minLength;\r\n      }\r\n      if (!settings.input) {\r\n          throw new Error(\"input undefined\");\r\n      }\r\n      var input = settings.input;\r\n      container.className = \"autocomplete \" + (settings.className || \"\");\r\n      // IOS implementation for fixed positioning has many bugs, so we will use absolute positioning\r\n      containerStyle.position = \"absolute\";\r\n      /**\r\n       * Detach the container from DOM\r\n       */\r\n      function detach() {\r\n          var parent = container.parentNode;\r\n          if (parent) {\r\n              parent.removeChild(container);\r\n          }\r\n      }\r\n      /**\r\n       * Clear debouncing timer if assigned\r\n       */\r\n      function clearDebounceTimer() {\r\n          if (debounceTimer) {\r\n              window.clearTimeout(debounceTimer);\r\n          }\r\n      }\r\n      /**\r\n       * Attach the container to DOM\r\n       */\r\n      function attach() {\r\n          if (!container.parentNode) {\r\n              doc.body.appendChild(container);\r\n          }\r\n      }\r\n      /**\r\n       * Check if container for autocomplete is displayed\r\n       */\r\n      function containerDisplayed() {\r\n          return !!container.parentNode;\r\n      }\r\n      /**\r\n       * Clear autocomplete state and hide container\r\n       */\r\n      function clear() {\r\n          // prevent the update call if there are pending AJAX requests\r\n          keypressCounter++;\r\n          items = [];\r\n          inputValue = \"\";\r\n          selected = undefined;\r\n          detach();\r\n      }\r\n      /**\r\n       * Update autocomplete position\r\n       */\r\n      function updatePosition() {\r\n          if (!containerDisplayed()) {\r\n              return;\r\n          }\r\n          containerStyle.height = \"auto\";\r\n          containerStyle.width = input.offsetWidth + \"px\";\r\n          var maxHeight = 0;\r\n          var inputRect;\r\n          function calc() {\r\n              var docEl = doc.documentElement;\r\n              var clientTop = docEl.clientTop || doc.body.clientTop || 0;\r\n              var clientLeft = docEl.clientLeft || doc.body.clientLeft || 0;\r\n              var scrollTop = window.pageYOffset || docEl.scrollTop;\r\n              var scrollLeft = window.pageXOffset || docEl.scrollLeft;\r\n              inputRect = input.getBoundingClientRect();\r\n              var top = inputRect.top + input.offsetHeight + scrollTop - clientTop;\r\n              var left = inputRect.left + scrollLeft - clientLeft;\r\n              containerStyle.top = top + \"px\";\r\n              containerStyle.left = left + \"px\";\r\n              maxHeight = window.innerHeight - (inputRect.top + input.offsetHeight);\r\n              if (maxHeight < 0) {\r\n                  maxHeight = 0;\r\n              }\r\n              containerStyle.top = top + \"px\";\r\n              containerStyle.bottom = \"\";\r\n              containerStyle.left = left + \"px\";\r\n              containerStyle.maxHeight = maxHeight + \"px\";\r\n          }\r\n          // the calc method must be called twice, otherwise the calculation may be wrong on resize event (chrome browser)\r\n          calc();\r\n          calc();\r\n          if (settings.customize && inputRect) {\r\n              settings.customize(input, inputRect, container, maxHeight);\r\n          }\r\n      }\r\n      /**\r\n       * Redraw the autocomplete div element with suggestions\r\n       */\r\n      function update() {\r\n          // delete all children from autocomplete DOM container\r\n          while (container.firstChild) {\r\n              container.removeChild(container.firstChild);\r\n          }\r\n          // function for rendering autocomplete suggestions\r\n          var render = function (item, currentValue) {\r\n              var itemElement = doc.createElement(\"div\");\r\n              itemElement.textContent = item.label || \"\";\r\n              return itemElement;\r\n          };\r\n          if (settings.render) {\r\n              render = settings.render;\r\n          }\r\n          // function to render autocomplete groups\r\n          var renderGroup = function (groupName, currentValue) {\r\n              var groupDiv = doc.createElement(\"div\");\r\n              groupDiv.textContent = groupName;\r\n              return groupDiv;\r\n          };\r\n          if (settings.renderGroup) {\r\n              renderGroup = settings.renderGroup;\r\n          }\r\n          var fragment = doc.createDocumentFragment();\r\n          var prevGroup = \"#9?$\";\r\n          items.forEach(function (item) {\r\n              if (item.group && item.group !== prevGroup) {\r\n                  prevGroup = item.group;\r\n                  var groupDiv = renderGroup(item.group, inputValue);\r\n                  if (groupDiv) {\r\n                      groupDiv.className += \" group\";\r\n                      fragment.appendChild(groupDiv);\r\n                  }\r\n              }\r\n              var div = render(item, inputValue);\r\n              if (div) {\r\n                  div.addEventListener(\"click\", function (ev) {\r\n                      settings.onSelect(item, input);\r\n                      clear();\r\n                      ev.preventDefault();\r\n                      ev.stopPropagation();\r\n                  });\r\n                  if (item === selected) {\r\n                      div.className += \" selected\";\r\n                  }\r\n                  fragment.appendChild(div);\r\n              }\r\n          });\r\n          container.appendChild(fragment);\r\n          if (items.length < 1) {\r\n              if (settings.emptyMsg) {\r\n                  var empty = doc.createElement(\"div\");\r\n                  empty.className = \"empty\";\r\n                  empty.textContent = settings.emptyMsg;\r\n                  container.appendChild(empty);\r\n              }\r\n              else {\r\n                  clear();\r\n                  return;\r\n              }\r\n          }\r\n          attach();\r\n          updatePosition();\r\n          updateScroll();\r\n      }\r\n      function updateIfDisplayed() {\r\n          if (containerDisplayed()) {\r\n              update();\r\n          }\r\n      }\r\n      function resizeEventHandler() {\r\n          updateIfDisplayed();\r\n      }\r\n      function scrollEventHandler(e) {\r\n          if (e.target !== container) {\r\n              updateIfDisplayed();\r\n          }\r\n          else {\r\n              e.preventDefault();\r\n          }\r\n      }\r\n      function keyupEventHandler(ev) {\r\n          var keyCode = ev.which || ev.keyCode || 0;\r\n          var ignore = settings.keysToIgnore || [38 /* Up */, 13 /* Enter */, 27 /* Esc */, 39 /* Right */, 37 /* Left */, 16 /* Shift */, 17 /* Ctrl */, 18 /* Alt */, 20 /* CapsLock */, 91 /* WindowsKey */, 9 /* Tab */];\r\n          for (var _i = 0, ignore_1 = ignore; _i < ignore_1.length; _i++) {\r\n              var key = ignore_1[_i];\r\n              if (keyCode === key) {\r\n                  return;\r\n              }\r\n          }\r\n          if (keyCode >= 112 /* F1 */ && keyCode <= 123 /* F12 */ && !settings.keysToIgnore) {\r\n              return;\r\n          }\r\n          // the down key is used to open autocomplete\r\n          if (keyCode === 40 /* Down */ && containerDisplayed()) {\r\n              return;\r\n          }\r\n          startFetch(0 /* Keyboard */);\r\n      }\r\n      /**\r\n       * Automatically move scroll bar if selected item is not visible\r\n       */\r\n      function updateScroll() {\r\n          var elements = container.getElementsByClassName(\"selected\");\r\n          if (elements.length > 0) {\r\n              var element = elements[0];\r\n              // make group visible\r\n              var previous = element.previousElementSibling;\r\n              if (previous && previous.className.indexOf(\"group\") !== -1 && !previous.previousElementSibling) {\r\n                  element = previous;\r\n              }\r\n              if (element.offsetTop < container.scrollTop) {\r\n                  container.scrollTop = element.offsetTop;\r\n              }\r\n              else {\r\n                  var selectBottom = element.offsetTop + element.offsetHeight;\r\n                  var containerBottom = container.scrollTop + container.offsetHeight;\r\n                  if (selectBottom > containerBottom) {\r\n                      container.scrollTop += selectBottom - containerBottom;\r\n                  }\r\n              }\r\n          }\r\n      }\r\n      /**\r\n       * Select the previous item in suggestions\r\n       */\r\n      function selectPrev() {\r\n          if (items.length < 1) {\r\n              selected = undefined;\r\n          }\r\n          else {\r\n              if (selected === items[0]) {\r\n                  selected = items[items.length - 1];\r\n              }\r\n              else {\r\n                  for (var i = items.length - 1; i > 0; i--) {\r\n                      if (selected === items[i] || i === 1) {\r\n                          selected = items[i - 1];\r\n                          break;\r\n                      }\r\n                  }\r\n              }\r\n          }\r\n      }\r\n      /**\r\n       * Select the next item in suggestions\r\n       */\r\n      function selectNext() {\r\n          if (items.length < 1) {\r\n              selected = undefined;\r\n          }\r\n          if (!selected || selected === items[items.length - 1]) {\r\n              selected = items[0];\r\n              return;\r\n          }\r\n          for (var i = 0; i < (items.length - 1); i++) {\r\n              if (selected === items[i]) {\r\n                  selected = items[i + 1];\r\n                  break;\r\n              }\r\n          }\r\n      }\r\n      function keydownEventHandler(ev) {\r\n          var keyCode = ev.which || ev.keyCode || 0;\r\n          if (keyCode === 38 /* Up */ || keyCode === 40 /* Down */ || keyCode === 27 /* Esc */) {\r\n              var containerIsDisplayed = containerDisplayed();\r\n              if (keyCode === 27 /* Esc */) {\r\n                  clear();\r\n              }\r\n              else {\r\n                  if (!containerIsDisplayed || items.length < 1) {\r\n                      return;\r\n                  }\r\n                  keyCode === 38 /* Up */\r\n                      ? selectPrev()\r\n                      : selectNext();\r\n                  update();\r\n              }\r\n              ev.preventDefault();\r\n              if (containerIsDisplayed) {\r\n                  ev.stopPropagation();\r\n              }\r\n              return;\r\n          }\r\n          if (keyCode === 13 /* Enter */) {\r\n              if (selected) {\r\n                  if (preventSubmit) {\r\n                      ev.preventDefault();\r\n                  }\r\n                  settings.onSelect(selected, input);\r\n                  clear();\r\n              }\r\n          }\r\n      }\r\n      function focusEventHandler() {\r\n          if (showOnFocus) {\r\n              startFetch(1 /* Focus */);\r\n          }\r\n      }\r\n      function startFetch(trigger) {\r\n          // If multiple keys were pressed, before we get an update from server,\r\n          // this may cause redrawing autocomplete multiple times after the last key was pressed.\r\n          // To avoid this, the number of times keyboard was pressed will be saved and checked before redraw.\r\n          var savedKeypressCounter = ++keypressCounter;\r\n          var inputText = input.value;\r\n          var cursorPos = input.selectionStart || 0;\r\n          if (inputText.length >= minLen || trigger === 1 /* Focus */) {\r\n              clearDebounceTimer();\r\n              debounceTimer = window.setTimeout(function () {\r\n                  settings.fetch(inputText, function (elements) {\r\n                      if (keypressCounter === savedKeypressCounter && elements) {\r\n                          items = elements;\r\n                          inputValue = inputText;\r\n                          selected = (items.length < 1 || disableAutoSelect) ? undefined : items[0];\r\n                          update();\r\n                      }\r\n                  }, trigger, cursorPos);\r\n              }, trigger === 0 /* Keyboard */ ? debounceWaitMs : 0);\r\n          }\r\n          else {\r\n              clear();\r\n          }\r\n      }\r\n      function blurEventHandler() {\r\n          // we need to delay clear, because when we click on an item, blur will be called before click and remove items from DOM\r\n          setTimeout(function () {\r\n              if (doc.activeElement !== input) {\r\n                  clear();\r\n              }\r\n          }, 200);\r\n      }\r\n      /**\r\n       * Fixes #26: on long clicks focus will be lost and onSelect method will not be called\r\n       */\r\n      container.addEventListener(\"mousedown\", function (evt) {\r\n          evt.stopPropagation();\r\n          evt.preventDefault();\r\n      });\r\n      /**\r\n       * Fixes #30: autocomplete closes when scrollbar is clicked in IE\r\n       * See: https://stackoverflow.com/a/9210267/13172349\r\n       */\r\n      container.addEventListener(\"focus\", function () { return input.focus(); });\r\n      /**\r\n       * This function will remove DOM elements and clear event handlers\r\n       */\r\n      function destroy() {\r\n          input.removeEventListener(\"focus\", focusEventHandler);\r\n          input.removeEventListener(\"keydown\", keydownEventHandler);\r\n          input.removeEventListener(keyUpEventName, keyupEventHandler);\r\n          input.removeEventListener(\"blur\", blurEventHandler);\r\n          window.removeEventListener(\"resize\", resizeEventHandler);\r\n          doc.removeEventListener(\"scroll\", scrollEventHandler, true);\r\n          clearDebounceTimer();\r\n          clear();\r\n      }\r\n      // setup event handlers\r\n      input.addEventListener(\"keydown\", keydownEventHandler);\r\n      input.addEventListener(keyUpEventName, keyupEventHandler);\r\n      input.addEventListener(\"blur\", blurEventHandler);\r\n      input.addEventListener(\"focus\", focusEventHandler);\r\n      window.addEventListener(\"resize\", resizeEventHandler);\r\n      doc.addEventListener(\"scroll\", scrollEventHandler, true);\r\n      return {\r\n          destroy: destroy\r\n      };\r\n  }\n\n  return autocomplete;\n\n})));\n//# sourceMappingURL=autocomplete.js.map\n","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {IAutocompleteItem} from \"../settings/setting_elements/Autocomplete\";\r\nimport SC_Plugin from \"../main\";\r\n\r\nexport function getVariableAutocompleteItems(plugin: SC_Plugin) {\r\n    if (0 === autocomplete_items.length) {\r\n        plugin.getVariables().forEach((variable) => {\r\n            autocomplete_items.push(...variable.getAutocompleteItems());\r\n        });\r\n    }\r\n    return autocomplete_items;\r\n}\r\n\r\nexport function resetVariableAutocompleteItems() {\r\n    while (autocomplete_items.length) {\r\n        autocomplete_items.pop();\r\n    }\r\n}\r\n\r\nconst autocomplete_items: IAutocompleteItem[] = [];","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport autocomplete from \"autocompleter\";\r\nimport {\r\n    parseYaml,\r\n    setIcon,\r\n} from \"obsidian\";\r\nimport SC_Plugin from \"../../main\";\r\nimport {AutocompleteResult} from \"autocompleter/autocomplete\";\r\nimport {getVariableAutocompleteItems} from \"../../variables/getVariableAutocompleteItems\";\r\nimport {gotoURL} from \"../../Common\";\r\n\r\n/**\r\n *\r\n * @param plugin Used for getting a list of Variable autocomplete items.\r\n * @param input_element\r\n * @param call_on_completion A function that will be called when a user has selected a suggestion and performed the autocomplete action. onChange event will not be called, because it would trigger opening the autocomplete menu again, so that's why a separate callback is used.\r\n * @param extra_autocomplete_items\r\n */\r\nexport function createAutocomplete(plugin: SC_Plugin, input_element: HTMLInputElement | HTMLTextAreaElement, call_on_completion: (field_value: string) => void, extra_autocomplete_items: IAutocompleteItem[] = []) {\r\n\r\n    const autocompleteMenu: AutocompleteResult =  autocomplete<IAutocompleteItem>({\r\n        input: input_element,\r\n        fetch: (input_value_but_not_used: string, update: (items: IAutocompleteItem[]) => void) => {\r\n            const autocomplete_items = merge_and_sort_autocomplete_items(getVariableAutocompleteItems(plugin), CustomAutocompleteItems, extra_autocomplete_items);\r\n            const max_suggestions = 30;\r\n\r\n            // Get the so far typed text - exclude everything that is on the right side of the caret.\r\n            const caret_position: number | null = input_element.selectionStart;\r\n            if (null === caret_position) {\r\n                throw new Error(\"createAutocomplete(): fetch(): caret_position is null.\");\r\n            }\r\n            const typed_text: string = input_element.value.slice(0, caret_position);\r\n            const search_query = get_search_query(typed_text);\r\n\r\n            if (\"\" === search_query.search_text) {\r\n                // No suggestions for empty word.\r\n                update([]);\r\n            } else {\r\n                // The word is not empty, so can suggest something.\r\n                let matched_items = autocomplete_items.filter(item => item_match(item, search_query));\r\n                sort_autocomplete_items(matched_items, search_query);\r\n                matched_items = matched_items.slice(0, max_suggestions); // Limit to a reasonable amount of suggestions.\r\n                update(matched_items);\r\n            }\r\n        },\r\n        onSelect: (item) => {\r\n            // A user has selected an item to be autocompleted\r\n\r\n            // Get the item text and already typed text\r\n            let supplement = item.value;\r\n            let caret_position: number | null = input_element.selectionStart;\r\n            if (null === caret_position) {\r\n                throw new Error(\"createAutocomplete(): fetch(): caret_position is null.\");\r\n            }\r\n            const typed_text = input_element.value.slice(0, caret_position);\r\n            const search_query = get_search_query(typed_text);\r\n            const search_text = search_query.search_text;\r\n\r\n            // Special case: Check if }} happens to appear after the caret\r\n            const after_caret = input_element.value.slice(caret_position, caret_position + 2);\r\n            if (\"}}\" === after_caret) {\r\n                // The replacing will happen in a {{variable}}.\r\n                // Do not accidentally insert another }} pair.\r\n                supplement = supplement.replace(/\\}\\}$/u, \"\"); // Only removes a trailing }} if there is one.\r\n            }\r\n\r\n            // Try to save part of the beginning, in case it seems like not being part of the search query.\r\n            let replace_start = find_starting_position(search_text, supplement); // The length difference of typed_text and search_text will be added here below.\r\n            if (false === replace_start) {\r\n                // This should never happen, but if it does, do not replace anything, just insert.\r\n                replace_start = caret_position;\r\n            } else {\r\n                // Adjust the position\r\n                replace_start += typed_text.length - search_text.length;\r\n            }\r\n\r\n            // Choose a method for doing the inserting\r\n            if (undefined !== document.execCommand) {\r\n                // execCommand() is deprecated, but available.\r\n                // Use it to do the insertion, because this way an undo history can be preserved.\r\n                input_element.setSelectionRange(replace_start, caret_position); // First select the part that will be replaced, because execCommand() does not support defining positions. This adds a cumbersome selection step to the undo history, but at least undoing works.\r\n                document.execCommand(\"insertText\", false, supplement);\r\n            } else {\r\n                // execCommand() is not available anymore.\r\n                // Use setRangeText() to do the insertion. It will clear undo history, but at least the insertion works.\r\n                input_element.setRangeText(supplement, replace_start, caret_position);\r\n            }\r\n\r\n            // Move the caret to a logical continuation point\r\n            caret_position = replace_start + supplement.length;\r\n            if (supplement.match(/:\\}\\}$/u)) {\r\n                // Place the caret after the colon, instead of after }}.\r\n                caret_position -= 2;\r\n            }\r\n            input_element.setSelectionRange(caret_position, caret_position);\r\n\r\n            // Call a hook\r\n            call_on_completion(input_element.value);\r\n        },\r\n        render: (item) => {\r\n            const div_element = document.createElement(\"div\");\r\n            div_element.createSpan({text: item.value, attr: {class: \"SC-autocomplete-value\"}});\r\n            if (item.help_text) {\r\n                div_element.createSpan({text: \": \", attr: {class: \"SC-autocomplete-separator\"}});\r\n                div_element.createSpan({attr: {class: \"SC-autocomplete-help-text\"}}).insertAdjacentHTML(\"beforeend\", item.help_text);\r\n            }\r\n\r\n            // Documentation link\r\n            const documentationLink: string | undefined = item.documentationLink;\r\n            if (undefined !== documentationLink) {\r\n                const documentationLinkElement = div_element.createEl(\"a\", {attr: {\"title\": \"Documentation: \" + item.value}}); // Use \"title\" instead of \"aria-label\", because I don't know how to make \"aria-label\" show a tooltip box on a custom element.\r\n                setIcon(documentationLinkElement, \"help\");\r\n                documentationLinkElement.addClass(\"SC-autocomplete-link-icon\");\r\n                documentationLinkElement.onClickEvent((event) => {\r\n                    gotoURL(documentationLink);\r\n                    // event.preventDefault(); Not needed, I guess.\r\n                    event.stopImmediatePropagation(); // Do not close the autocomplete menu.\r\n                });\r\n            }\r\n\r\n            return div_element;\r\n        },\r\n        minLength: 2, // Minimum length when autocomplete menu should pop up.\r\n        className: \"SC-autocomplete\", // The component always has a class 'autocomplete', but add 'SC-autocomplete' so that SC's CSS can target 'SC-autocomplete', so it will not mess up stuff if Obsidian happens to have an element with class 'autocomplete'.\r\n        keysToIgnore: [ 38 /* Up */, 13 /* Enter */, 27 /* Esc */, 16 /* Shift */, 17 /* Ctrl */, 18 /* Alt */, 20 /* CapsLock */, 91 /* WindowsKey */, 9 /* Tab */ ], // Defined just to prevent ignoring left and right keys.\r\n        preventSubmit: true, // Prevents creating newlines in textareas when enter is pressed in the autocomplete menu.\r\n    });\r\n\r\n    // Make the plugin able to close the menu if the plugin is disabled (or restarted).\r\n    plugin.registerAutocompleteMenu(autocompleteMenu);\r\n}\r\n\r\nexport interface IAutocompleteItem {\r\n    help_text: string;\r\n    value: string;\r\n    group: string;\r\n    type: AutocompleteSearchQueryType;\r\n    documentationLink?: string;\r\n}\r\n\r\nfunction item_match(item: IAutocompleteItem, search_query: IAutocompleteSearchQuery): boolean {\r\n    const item_value = item.value.toLocaleLowerCase();\r\n    const search_text = search_query.search_text.toLocaleLowerCase();\r\n\r\n    // Match query type\r\n    if (item.type !== search_query.search_type) {\r\n        // If the query type is different, do not include this item.\r\n        // This can happen e.g. if {{ is typed, and the item is not a variable, or {{! is typed, and the item is not an unescaped variable.\r\n        return false;\r\n    }\r\n\r\n    // Match text\r\n    let search_character: string;\r\n    let search_position = 0;\r\n    for (let search_character_index = 0; search_character_index < search_text.length; search_character_index++) {\r\n        search_character = search_text[search_character_index];\r\n        if (item_value.includes(search_character, search_position)) {\r\n            // This character was found in item_value.\r\n            search_position = item_value.indexOf(search_character, search_position) + 1;\r\n        } else {\r\n            // This character was not found.\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\n\r\nfunction find_starting_position(typed_text: string, supplement: string) {\r\n    typed_text = typed_text.toLocaleLowerCase();\r\n    supplement = supplement.toLocaleLowerCase();\r\n    for (let supplement_index = supplement.length; supplement_index >= 0; supplement_index--) {\r\n        const partial_supplement = supplement.slice(0, supplement_index);\r\n        if (typed_text.contains(partial_supplement)) {\r\n            return typed_text.indexOf(partial_supplement);\r\n        }\r\n    }\r\n    return false;\r\n}\r\n\r\n/**\r\n * Sorts in place, does not make a copy.\r\n * @param autocomplete_items\r\n * @param search_query\r\n */\r\nfunction sort_autocomplete_items(autocomplete_items: IAutocompleteItem[], search_query: IAutocompleteSearchQuery): void {\r\n\r\n    const search_text_excluding_curly_brackets = search_query.search_text.replace(/^{{!?/, \"\");\r\n\r\n    function get_common_beginning_length(autocomplete_item: IAutocompleteItem, search_query: IAutocompleteSearchQuery) {\r\n        const search_text = search_query.search_text.toLocaleLowerCase();\r\n        const item_value = autocomplete_item.value.toLocaleLowerCase();\r\n        const shortest_length = Math.min(search_text.length, item_value.length);\r\n        for (let character_index = 0; character_index < shortest_length; character_index++) {\r\n            const search_character = search_text[character_index];\r\n            const item_character = item_value[character_index];\r\n            if (search_character !== item_character) {\r\n                // The common beginning has ended.\r\n                return character_index;\r\n            }\r\n        }\r\n        return shortest_length;\r\n    }\r\n\r\n    autocomplete_items.sort((a: IAutocompleteItem, b: IAutocompleteItem) => {\r\n        const boost_a = Math.max(get_common_beginning_length(a, search_query), 1); // Boosts are used as multipliers,\r\n        const boost_b = Math.max(get_common_beginning_length(b, search_query), 1); // so they cannot be zero.\r\n        const a_length = a.value.length * boost_b; // boost_b worsens A (= makes it artificially \"longer\")\r\n        const b_length = b.value.length * boost_a; // boost_a worsens B\r\n        // Determine sorting method. If the search query is just a couple of characters, the matches would be quite vague, sorting by the matched items' length would not tell much, and the list would just look strangely ordered.\r\n        if (search_text_excluding_curly_brackets.length < 2 || a_length === b_length) {\r\n            // Sort alphabetically.\r\n            return a.value > b.value ? 1 : -1;\r\n        } else {\r\n            // Sort by lengths. The shortest item is preferred. If an item has a long common beginning with the search query, boost the item up.\r\n            return a_length - b_length;\r\n        }\r\n    });\r\n}\r\n\r\n\r\nconst CustomAutocompleteItems: IAutocompleteItem[] = [];\r\n\r\nexport function addCustomAutocompleteItems(custom_autocomplete_yaml: string) {\r\n\r\n    // Ensure the content is not empty\r\n    if (0 === custom_autocomplete_yaml.trim().length) {\r\n        return \"The content is empty.\";\r\n    }\r\n\r\n    // Try to parse YAML syntax\r\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    let yaml: any; // 'any' is defined in obsidian.d.ts for the return type of parseYaml(), so I made ESLint ignore it.\r\n    try {\r\n        yaml = parseYaml(custom_autocomplete_yaml);\r\n    } catch (error) {\r\n        // A syntax error has appeared.\r\n        return error.message;\r\n    }\r\n    if (null === yaml || typeof yaml !== \"object\") {\r\n        return \"Unable to parse the content due to unknown reason.\";\r\n    }\r\n\r\n    // Iterate autocomplete item groups\r\n    const group_names = Object.getOwnPropertyNames(yaml);\r\n    const error_messages: string[] = [];\r\n    group_names.forEach((group_name: string) => {\r\n        const group_items = yaml[group_name];\r\n        const group_item_values = Object.getOwnPropertyNames(group_items);\r\n\r\n        // Iterate all autocomplete items in the group\r\n        group_item_values.forEach((autocomplete_item_value: string) => {\r\n            const autocomplete_item_label = group_items[autocomplete_item_value];\r\n            if (typeof autocomplete_item_label !== \"string\") {\r\n                error_messages.push(\"Autocomplete item '\" + autocomplete_item_value + \"' has an incorrect help text type: \" + autocomplete_item_label + \" is a \" + typeof autocomplete_item_label + \", but it should be a string.\");\r\n                return;\r\n            }\r\n\r\n            // Determine a correct type for the item\r\n            let type: AutocompleteSearchQueryType = \"other\";\r\n            if (autocomplete_item_value.startsWith(\"{{\")) {\r\n                // This is a variable\r\n                type = \"normal-variable\";\r\n            }\r\n\r\n            // The item is ok, add it to the list\r\n            CustomAutocompleteItems.push({\r\n                value: autocomplete_item_value,\r\n                help_text: autocomplete_item_label,\r\n                group: group_name,\r\n                type: type,\r\n            });\r\n\r\n            if (type === \"normal-variable\") {\r\n                // Add an unescaped version of the variable, too\r\n                CustomAutocompleteItems.push({\r\n                    value: autocomplete_item_value.replace(/^\\{\\{/u, \"{{!\"), // Add an exclamation mark to the variable name.\r\n                    help_text: autocomplete_item_label,\r\n                    group: group_name,\r\n                    type: \"unescaped-variable\",\r\n                });\r\n            }\r\n        });\r\n    });\r\n    if (error_messages.length > 0) {\r\n        // Something failed\r\n        return error_messages.join(\"; \");\r\n    }\r\n\r\n    // All ok\r\n    return true;\r\n}\r\n\r\n/**\r\n * TODO: Can the sorting be removed from here? Now autocomplete items are sorted again every time when filtering, based on the keyword (https://github.com/Taitava/obsidian-shellcommands/issues/249).\r\n * @param autocomplete_item_sets\r\n */\r\nfunction merge_and_sort_autocomplete_items(...autocomplete_item_sets: IAutocompleteItem[][]) {\r\n    const merged_autocomplete_items: IAutocompleteItem[] = (new Array<IAutocompleteItem>()).concat(...autocomplete_item_sets);\r\n    return merged_autocomplete_items.sort((a, b) => {\r\n        // First compare groups\r\n        if (a.group < b.group) {\r\n            // a's group should come before b's group.\r\n            return -1;\r\n        } else if (a.group > b.group) {\r\n            // a's group should come after b's group.\r\n            return 1;\r\n        } else {\r\n            // The groups are the same.\r\n            // Compare values.\r\n            if (a.value < b.value) {\r\n                // a should come before b.\r\n                return -1;\r\n            } else if (a.value > b.value) {\r\n                // a should come after b.\r\n                return 1;\r\n            } else {\r\n                // The values are the same.\r\n                // The order does not matter.\r\n                return 0;\r\n            }\r\n        }\r\n    });\r\n}\r\n\r\ntype AutocompleteSearchQueryType = \"other\" | \"normal-variable\" | \"unescaped-variable\";\r\ninterface IAutocompleteSearchQuery {\r\n    search_text: string;\r\n    search_type: AutocompleteSearchQueryType;\r\n}\r\n\r\n/**\r\n * Reduces an input string to the nearest logical word.\r\n * @param typed_text\r\n */\r\nfunction get_search_query(typed_text: string): IAutocompleteSearchQuery {\r\n    const searchTextMatchArray: RegExpMatchArray | null = typed_text.match(/\\S*?$/u); // An array, but only one match is expected.\r\n    if (null === searchTextMatchArray) {\r\n        throw new Error(\"get_search_query(): Regex match failed.\");\r\n    }\r\n    let search_text = searchTextMatchArray[0]; // Reduce the text - limit to a single word (= exclude spaces and everything before them).\r\n    let search_type: AutocompleteSearchQueryType = \"other\"; // May be overwritten.\r\n\r\n    if (search_text.contains(\"}}\")) {\r\n        // The query happens right after a {{variable}}.\r\n        // Make the query string to start after the }} pair, i.e. remove }} and everything before it. This improves the search.\r\n        search_text = search_text.replace(/.+\\}\\}/u, \"\");\r\n    }\r\n    if (search_text.contains(\"{{\")) {\r\n        // A {{variable}} is being queried.\r\n        // Make the query string to start from the {{ pair, i.e. remove everything before {{ . This improves the search.\r\n        search_text = search_text.replace(/.+\\{\\{/u, \"{{\");\r\n        if (search_text.contains(\"{{!\")) {\r\n            // An _unescaped_ variable is searched for.\r\n            search_type = \"unescaped-variable\";\r\n        } else {\r\n            // A normal variable is searched for.\r\n            search_type = \"normal-variable\";\r\n        }\r\n    }\r\n    return {\r\n        search_text: search_text,\r\n        search_type: search_type,\r\n    };\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Modal} from \"../../SC_Modal\";\r\nimport SC_Plugin from \"../../main\";\r\nimport {\r\n    Setting,\r\n} from \"obsidian\";\r\nimport {OutputWrapper} from \"./OutputWrapper\";\r\nimport {createAutocomplete} from \"../../settings/setting_elements/Autocomplete\";\r\nimport {Variable_Output} from \"../../variables/Variable_Output\";\r\n\r\nexport class OutputWrapperSettingsModal extends SC_Modal {\r\n\r\n    private approved = false;\r\n\r\n    constructor(\r\n        plugin: SC_Plugin,\r\n        private readonly output_wrapper: OutputWrapper,\r\n\r\n        /** Can be undefined if the output wrapper is created from a place where there is no name element. */\r\n        private readonly output_wrapper_name_setting?: Setting,\r\n\r\n        /** If defined, a button will be added and on_after_approval() / on_after_cancelling() will be called depending on whether the button was clicked or not. */\r\n        private readonly ok_button_text?: string,\r\n\r\n        private readonly on_after_approval?: () => void,\r\n        private readonly on_after_cancelling?: () => void,\r\n    ) {\r\n        super(plugin);\r\n    }\r\n\r\n    public onOpen(): void {\r\n        super.onOpen();\r\n        const container_element = this.modalEl.createDiv();\r\n        container_element.addClass(\"SC-setting-group\"); // Make setting fields wider in this container.\r\n\r\n        // Title\r\n        const title_setting = new Setting(container_element)\r\n            .setName(\"Output wrapper title\")\r\n            .setDesc(\"Only used in settings, will not appear in output.\")\r\n            .addText(text => text\r\n                .setValue(this.output_wrapper.getTitle())\r\n                .onChange(async (new_title: string) => {\r\n                    this.output_wrapper.getConfiguration().title = new_title;\r\n                    await this.plugin.saveSettings();\r\n\r\n                    // Update the title in a name setting. (Only if the modal was created from a place where an OutputWrapper name element exists).\r\n                    this.output_wrapper_name_setting?.setName(new_title);\r\n                })\r\n            )\r\n        ;\r\n        const title_input_element: HTMLInputElement = title_setting.controlEl.find(\"input\") as HTMLInputElement;\r\n\r\n        // Content\r\n        const output_variable = new Variable_Output(this.plugin, \"\"); // For getting an autocomplete item.\r\n        new Setting(container_element)\r\n            .setName(\"Content\")\r\n            .setDesc(\"Use {{output}} as a placeholder for text that will be received from a shell command. Other variables are available, too.\")\r\n            .addTextArea(textarea_component => textarea_component\r\n                .setValue(this.output_wrapper.configuration.content)\r\n                .onChange(async (new_content: string) => {\r\n                    this.output_wrapper.configuration.content = new_content;\r\n                    await this.plugin.saveSettings();\r\n                })\r\n                .then((textarea_component) => {\r\n                    // Autocomplete for Content.\r\n                    if (this.plugin.settings.show_autocomplete_menu) {\r\n                        createAutocomplete(\r\n                            this.plugin,\r\n                            textarea_component.inputEl,\r\n                            () => textarea_component.onChanged(),\r\n                            output_variable.getAutocompleteItems(),\r\n                        );\r\n                    }\r\n                }),\r\n            )\r\n        ;\r\n\r\n        // Focus on the title field.\r\n        title_input_element.focus();\r\n\r\n        // Ok button\r\n        const okButtonText: string | undefined = this.ok_button_text;\r\n        if (okButtonText) {\r\n            new Setting(container_element)\r\n                .addButton(button => button\r\n                    .setButtonText(okButtonText)\r\n                    .onClick(() => this.approve()),\r\n                )\r\n            ;\r\n        }\r\n    }\r\n\r\n    protected approve(): void {\r\n        if (this.on_after_approval) {\r\n            this.approved = true;\r\n            this.on_after_approval();\r\n        }\r\n        this.close();\r\n    }\r\n\r\n    public onClose(): void {\r\n        super.onClose();\r\n\r\n        // Call a cancelling hook if one is defined (and if the closing happens due to cancelling, i.e. the ok button is NOT clicked).\r\n        if (!this.approved && this.on_after_cancelling) {\r\n            this.on_after_cancelling();\r\n        }\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    Model,\r\n    ParentModelOneToManyIdRelation,\r\n} from \"../Model\";\r\nimport {Setting} from \"obsidian\";\r\nimport {\r\n    OutputWrapper,\r\n    OutputWrapperConfiguration,\r\n} from \"./OutputWrapper\";\r\nimport {debugLog} from \"../../Debug\";\r\nimport {getIDGenerator} from \"../../IDGenerator\";\r\nimport {OutputStream} from \"../../output_channels/OutputChannelCode\";\r\nimport {OutputWrapperSettingsModal} from \"./OutputWrapperSettingsModal\";\r\nimport {SC_MainSettings} from \"../../settings/SC_MainSettings\";\r\n\r\nexport class OutputWrapperModel extends Model {\r\n\r\n    private output_wrappers = new OutputWrapperMap();\r\n\r\n    protected _createSettingFields(output_wrapper: OutputWrapper, container_element: HTMLElement): Setting {\r\n        debugLog(\"Creating setting fields for an OutputWrapper instance.\");\r\n        const output_wrapper_name_setting = new Setting(container_element)\r\n            // Configuration button\r\n            .setName(output_wrapper.getTitle())\r\n            .addExtraButton(button => button\r\n                .setTooltip(\"Define output wrapper content\")\r\n                .setIcon(\"gear\")\r\n                .onClick(() => {\r\n                    this.openSettingsModal(output_wrapper, output_wrapper_name_setting);\r\n                }),\r\n            )\r\n        ;\r\n        return output_wrapper_name_setting;\r\n    }\r\n\r\n    protected defineParentConfigurationRelation(output_wrapper: OutputWrapper): ParentModelOneToManyIdRelation {\r\n        return {\r\n            type: \"one-to-many-id\",\r\n            key: \"output_wrappers\",\r\n            id: output_wrapper.getID(),\r\n        };\r\n    }\r\n\r\n    public getSingularName(): string {\r\n        return \"Output wrapper\";\r\n    }\r\n\r\n    public loadInstances(parent_configuration: SC_MainSettings): OutputWrapperMap {\r\n        debugLog(\"Loading OutputWrapper instances.\");\r\n        this.output_wrappers = new OutputWrapperMap();\r\n        parent_configuration.output_wrappers.forEach((output_wrapper_configuration: OutputWrapperConfiguration) => {\r\n            const output_wrapper = new OutputWrapper(this, this.plugin, output_wrapper_configuration, parent_configuration);\r\n            this.output_wrappers.set(output_wrapper_configuration.id, output_wrapper);\r\n        });\r\n        return this.output_wrappers;\r\n    }\r\n\r\n    public newInstance(parent_configuration: SC_MainSettings): OutputWrapper {\r\n        debugLog(\"Creating a new OutputWrapper instance.\");\r\n        // TODO: Move this logic to the base Model class.\r\n\r\n        // Setup a default configuration and generate an ID\r\n        const output_wrapper_configuration = this.getDefaultConfiguration();\r\n\r\n        // Instantiate an OutputWrapper\r\n        const output_wrapper = new OutputWrapper(this, this.plugin, output_wrapper_configuration, this.plugin.settings);\r\n        this.output_wrappers.set(output_wrapper.getID(), output_wrapper);\r\n\r\n        // Store the configuration into plugin's settings\r\n        parent_configuration.output_wrappers.push(output_wrapper_configuration);\r\n\r\n        // Return the OutputWrapper\r\n        return output_wrapper;\r\n    }\r\n\r\n    public validateValue(output_wrapper: OutputWrapper, field: string, value: unknown): Promise<void> {\r\n        // No validation is needed, I guess. 'Title' and 'content' can both be empty, although an empty title does not make sense.\r\n        return Promise.resolve(undefined);\r\n    }\r\n\r\n    public openSettingsModal(output_wrapper: OutputWrapper, output_wrapper_name_setting: Setting) {\r\n        debugLog(\"Opening settings modal for an OutputWrapper instance.\");\r\n        const modal = new OutputWrapperSettingsModal(this.plugin, output_wrapper, output_wrapper_name_setting);\r\n        modal.open();\r\n    }\r\n\r\n    public getDefaultConfiguration(): OutputWrapperConfiguration {\r\n        return {\r\n            id: getIDGenerator().generateID(),\r\n            title: \"\",\r\n            content: \"\",\r\n        };\r\n    }\r\n\r\n    protected _deleteInstance(deletable_output_wrapper: OutputWrapper): void {\r\n        debugLog(\"Deleting an OutputWrapper instance.\");\r\n\r\n        // Remove the OutputWrapper from all TShellCommands that use it.\r\n        const shell_commands = this.plugin.getTShellCommands();\r\n        for (const shell_command_id in shell_commands) {\r\n            const t_shell_command = shell_commands[shell_command_id];\r\n            const output_wrappers = t_shell_command.getConfiguration().output_wrappers;\r\n            Object.each(output_wrappers, (output_wrapper_id: string, output_stream: OutputStream) => {\r\n                if (output_wrapper_id === deletable_output_wrapper.getID()) {\r\n                    // A shell command uses the output wrapper that is about to be deleted.\r\n                    // Configure the shell command not to use any output wrapper.\r\n                    output_wrappers[output_stream] = null;\r\n                }\r\n            });\r\n        }\r\n\r\n        // Remove the OutputWrapper from this class's internal list.\r\n        this.output_wrappers.delete(deletable_output_wrapper.getID());\r\n    }\r\n\r\n}\r\n\r\nexport class OutputWrapperMap extends Map<string, OutputWrapper> {}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../main\";\r\nimport {debugLog} from \"../Debug\";\r\nimport {\r\n    CustomVariableModel,\r\n    introduceModelClass,\r\n    PromptFieldModel,\r\n    PromptModel,\r\n} from \"../imports\";\r\nimport {OutputWrapperModel} from \"./output_wrapper/OutputWrapperModel\";\r\n\r\nexport function introduceModels(plugin: SC_Plugin) {\r\n    debugLog(\"Introducing models.\");\r\n\r\n    // Keep in alphabetical order, if possible.\r\n    introduceModelClass(new CustomVariableModel(plugin));\r\n    introduceModelClass(new PromptFieldModel(plugin));\r\n    introduceModelClass(new PromptModel(plugin));\r\n    introduceModelClass(new OutputWrapperModel(plugin));\r\n}\r\n","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    GlobalVariableDefaultValueConfiguration,\r\n    Variable,\r\n} from \"./Variable\";\r\nimport SC_Plugin from \"../main\";\r\nimport {CustomVariableInstance} from \"../models/custom_variable/CustomVariableInstance\";\r\nimport {resetVariableAutocompleteItems} from \"./getVariableAutocompleteItems\";\r\nimport {debugLog} from \"../Debug\";\r\n\r\n/**\r\n * This class serves as the actual operational variable class for custom variables. It's paired with the CustomVariableInstance class, which acts\r\n * as a configuration class to handle settings together with CustomVariableModel class.\r\n */\r\nexport class CustomVariable extends Variable {\r\n\r\n    private value: string | null = null; // TODO: When implementing variable types, make this class abstract and let subclasses define the type of this property.\r\n\r\n    protected always_available = false;\r\n\r\n    constructor(\r\n        plugin: SC_Plugin,\r\n        private custom_variable_instance: CustomVariableInstance\r\n    ) {\r\n        super(plugin);\r\n        this.updateProperties();\r\n        debugLog(`Loaded CustomVariable ${this.variable_name}.`);\r\n    }\r\n\r\n    public async generateValue(): Promise<string> {\r\n        if (null === this.value) {\r\n            debugLog(`Custom variable ${this.variable_name} does not have a value yet, and no default value is defined.`);\r\n            this.throw(\"This custom variable does not have a value yet, and no default value is defined.\");\r\n        }\r\n        return this.value;\r\n    }\r\n\r\n    /**\r\n     * TODO: Make it possible to prevent calling onChange callbacks:\r\n     *  - Make it possible to call the callbacks later outside this class.\r\n     *  - This makes it possible to prevent unnecessary CustomVariableView updates when multiple CustomVariables are assigned values in one go (via Shell command URI).\r\n     *  - Store the old value into some kind of history list.\r\n     *  - When calling the callbacks, the current CustomVariable should be passed as a parameter instead of the 'value' and 'old_value' parameters (which can be accessed via the CustomVariable object).\r\n     *\r\n     * @param value\r\n     */\r\n    public async setValue(value: string) {\r\n        const old_value = this.value;\r\n        debugLog(`CustomVariable ${this.variable_name}: Setting value to: ${value} (old was: ${old_value}).`);\r\n        this.value = value;\r\n\r\n        // Call the onChange hook.\r\n        await this.callOnChangeCallbacks(value, old_value ?? \"\"); // Use \"\" if old_value is null.\r\n    }\r\n\r\n    /**\r\n     * Retrieves variable_name and help_text properties from the associated CustomVariableInstance.\r\n     * Called when loading the CustomVariable and when the associated CustomVariableInstance's settings are changed.\r\n     */\r\n    public updateProperties() {\r\n        debugLog(`CustomVariable ${this.variable_name}: Updating variable name and help text.`);\r\n        this.variable_name = this.custom_variable_instance.getPrefixedName();\r\n        this.help_text = this.custom_variable_instance.configuration.description;\r\n        resetVariableAutocompleteItems(); // Make autocomplete lists reload their content in order to get the new variable name/help text.\r\n    }\r\n\r\n    public getIdentifier() {\r\n        return this.custom_variable_instance.getID();\r\n    }\r\n\r\n    /**\r\n     * Adds the given callback function to a stack of functions that will be called whenever this CustomVariable's value changes.\r\n     * @param on_change_callback\r\n     */\r\n    public onChange(on_change_callback: TCustomVariableOnChangeCallback) {\r\n        this.on_change_callbacks.add(on_change_callback);\r\n    }\r\n    private on_change_callbacks = new Set<TCustomVariableOnChangeCallback>();\r\n\r\n    private async callOnChangeCallbacks(new_value: string, old_value: string) {\r\n        debugLog(`CustomVariable ${this.variable_name}: Calling onChange callbacks.`);\r\n        for (const on_change_callback of this.on_change_callbacks) {\r\n            await on_change_callback(this, new_value, old_value);\r\n        }\r\n    }\r\n\r\n    public getConfiguration() {\r\n        return this.custom_variable_instance.configuration;\r\n    }\r\n\r\n    public getGlobalDefaultValueConfiguration(): GlobalVariableDefaultValueConfiguration | null {\r\n        return this.custom_variable_instance.configuration.default_value;\r\n    }\r\n}\r\n\r\ntype TCustomVariableOnChangeCallback = (variable: CustomVariable, new_value: string, old_value: string) => Promise<void>;","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_MainSettings} from \"../../settings/SC_MainSettings\";\r\nimport {\r\n    CustomVariable,\r\n    CustomVariableConfiguration,\r\n    CustomVariableModel,\r\n    getIDGenerator,\r\n    Instance,\r\n} from \"../../imports\";\r\nimport {debugLog} from \"../../Debug\";\r\n\r\n/**\r\n * This class serves as an accessor to CustomVariable configurations. It's paired with the CustomVariable class, which acts\r\n * as an operational class to implement the variable functionality.\r\n *\r\n * TODO: Decide a better name for this class. It's too easy to confuse with the CustomVariable class name.\r\n */\r\nexport class CustomVariableInstance extends Instance {\r\n    public readonly parent_configuration: SC_MainSettings;\r\n    public configuration: CustomVariableConfiguration;\r\n    private custom_variable: CustomVariable | null = null;\r\n\r\n    constructor(\r\n        public readonly model: CustomVariableModel,\r\n        configuration: CustomVariableConfiguration,\r\n        parent_configuration: SC_MainSettings,\r\n    ) {\r\n        super(model, configuration, parent_configuration);\r\n\r\n        // Introduce the ID to an ID generator so that it won't accidentally generate the same ID again when creating new CustomVariableInstances.\r\n        getIDGenerator().addReservedID(configuration.id);\r\n\r\n        debugLog(`Loaded CustomVariableInstance ${this.getID()}.`);\r\n    }\r\n\r\n    public getID() {\r\n        return this.configuration.id;\r\n    }\r\n\r\n    public getFullName() {\r\n        return `{{${this.getPrefixedName()}}}`;\r\n    }\r\n\r\n    /**\r\n     * Adds an underscore in front of the name.\r\n     */\r\n    public getPrefixedName() {\r\n        return \"_\" + this.configuration.name;\r\n    }\r\n\r\n    public getTitle(): string {\r\n        return this.getFullName();\r\n    }\r\n\r\n    public getCustomVariable(): CustomVariable {\r\n        if (!this.custom_variable) {\r\n            debugLog(`CustomVariableInstance ${this.getID()}: Cannot find a CustomVariable. Maybe it's not loaded?`);\r\n            throw new Error(this.constructor.name + \".getVariable(): Cannot find a CustomVariable. Maybe it's not loaded?\");\r\n        }\r\n        return this.custom_variable;\r\n    }\r\n\r\n    public createCustomVariable(): CustomVariable {\r\n        debugLog(`CustomVariableInstance ${this.getID()}: Creating an operational CustomVariable.`);\r\n        this.custom_variable = new CustomVariable(this.model.plugin, this);\r\n        this.custom_variable.onChange(async () => await this.model.plugin.updateCustomVariableViews());\r\n        return this.custom_variable;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Event} from \"./SC_Event\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\n\r\nexport class SC_Event_onLayoutReady extends SC_Event {\r\n    protected static readonly event_code = \"on-layout-ready\";\r\n    protected static readonly event_title = \"Obsidian starts\";\r\n    protected register_after_changing_settings = false;\r\n\r\n    protected _register(t_shell_command: TShellCommand) {\r\n        this.app.workspace.onLayoutReady(async () => await this.trigger(t_shell_command));\r\n        return false; // The base class does not need to register anything.\r\n    }\r\n\r\n    protected _unregister(t_shell_command: TShellCommand): void {\r\n        // No need to unregister, because this event happens only once when Obsidian starts. If the event is not enabled for a shell command, next time Obsidian starts, this event won't get registered.\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_WorkspaceEvent} from \"./SC_WorkspaceEvent\";\r\n\r\nexport class SC_Event_onQuit extends SC_WorkspaceEvent {\r\n    protected static readonly event_code = \"on-quit\";\r\n    protected static readonly event_title = \"Obsidian quits\";\r\n    protected readonly workspace_event = \"quit\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_WorkspaceEvent} from \"./SC_WorkspaceEvent\";\r\n\r\nexport class SC_Event_onActiveLeafChanged extends SC_WorkspaceEvent {\r\n    protected static readonly event_code = \"on-active-leaf-changed\";\r\n    protected static readonly event_title = \"Switching the active pane\";\r\n    protected readonly workspace_event = \"active-leaf-change\";\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Event} from \"./SC_Event\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {SC_EventConfiguration} from \"./SC_EventConfiguration\";\r\nimport {Notice, Setting} from \"obsidian\";\r\n\r\n\r\nexport class SC_Event_EveryNSeconds extends SC_Event {\r\n    protected static readonly event_code = \"every-n-seconds\";\r\n    protected static readonly event_title = \"Every n seconds\";\r\n    protected default_configuration: Configuration = {\r\n        enabled: false,\r\n        seconds: 60,\r\n    };\r\n    private intervals_ids: {\r\n        [key: string]: number; // key: TShellCommand id, value: setInterval() id.\r\n    } = {};\r\n\r\n    protected _register(t_shell_command: TShellCommand) {\r\n        const milliseconds: number = this.getConfiguration(t_shell_command).seconds * 1000;\r\n        const interval_id: number = window.setInterval(\r\n            async () => await this.trigger(t_shell_command),\r\n            milliseconds,\r\n        );\r\n        this.plugin.registerInterval(interval_id);\r\n        this.intervals_ids[t_shell_command.getId()] = interval_id;\r\n        return false; // The base class does not need to register anything.\r\n    }\r\n\r\n    protected _unregister(t_shell_command: TShellCommand): void {\r\n        window.clearInterval(this.intervals_ids[t_shell_command.getId()]);\r\n    }\r\n\r\n    /**\r\n     * Overridden only to change the return type.\r\n     * @param t_shell_command\r\n     * @protected\r\n     */\r\n    protected getConfiguration(t_shell_command: TShellCommand): Configuration {\r\n        return super.getConfiguration(t_shell_command) as Configuration;\r\n    }\r\n\r\n    public createExtraSettingsFields(extra_settings_container: HTMLDivElement, t_shell_command: TShellCommand): void {\r\n        const configuration: Configuration = this.getConfiguration(t_shell_command);\r\n        let apply_seconds: number;\r\n        new Setting(extra_settings_container)\r\n            .setName(\"Seconds\")\r\n            .setDesc(\"Needs to be at least 1. Currently supports only integers.\")\r\n            .addText(text => text\r\n                .setValue(configuration.seconds.toString())\r\n                .onChange((raw_value: string) => {\r\n                    apply_seconds = parseInt(raw_value);\r\n                    // Don't save here, because the user might still be editing the number.\r\n                }),\r\n            )\r\n            .addButton(button => button\r\n                .setButtonText(\"Apply\")\r\n                .onClick(async () => {\r\n                    if (undefined == apply_seconds || apply_seconds === this.getConfiguration(t_shell_command).seconds) {\r\n                        new Notice(\"You didn't change the seconds!\");\r\n                    } else if (isNaN(apply_seconds)) {\r\n                        new Notice(\"The seconds need to be an integer!\");\r\n                    } else if (apply_seconds <= 0) {\r\n                        new Notice(\"The seconds need to be at least 1!\");\r\n                    } else {\r\n                        // All ok, save.\r\n                        this.getConfiguration(t_shell_command).seconds = apply_seconds;\r\n                        await this.plugin.saveSettings();\r\n\r\n                        // Re-register to apply the change\r\n                        this.unregister(t_shell_command);\r\n                        this.register(t_shell_command);\r\n\r\n                        // Done\r\n                        this.noticeAboutEnabling(t_shell_command);\r\n                    }\r\n\r\n                }),\r\n            )\r\n        ;\r\n    }\r\n\r\n    public onAfterEnabling(t_shell_command: TShellCommand): void {\r\n        this.noticeAboutEnabling(t_shell_command);\r\n    }\r\n\r\n    private noticeAboutEnabling(t_shell_command: TShellCommand) {\r\n        new Notice(\"The shell command will run every \" + this.getConfiguration(t_shell_command).seconds + \" seconds\");\r\n    }\r\n}\r\n\r\ninterface Configuration extends SC_EventConfiguration {\r\n    seconds: number,\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {Editor, MarkdownView, Menu} from \"obsidian\";\r\nimport {SC_MenuEvent} from \"./SC_MenuEvent\";\r\n\r\nexport class SC_Event_EditorMenu extends SC_MenuEvent {\r\n    protected static readonly event_code = \"editor-menu\";\r\n    protected static readonly event_title = \"Editor menu\";\r\n    protected readonly workspace_event = \"editor-menu\";\r\n\r\n    protected getTrigger(t_shell_command: TShellCommand) {\r\n        return async (menu: Menu, editor: Editor, view: MarkdownView) => {\r\n            await this.addTShellCommandToMenu(t_shell_command, menu);\r\n        };\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../main\";\r\nimport {SC_Event_onLayoutReady} from \"./SC_Event_onLayoutReady\";\r\nimport {SC_Event_onQuit} from \"./SC_Event_onQuit\";\r\nimport {SC_Event_onActiveLeafChanged} from \"./SC_Event_onActiveLeafChanged\";\r\nimport {SC_Event_EveryNSeconds} from \"./SC_Event_EveryNSeconds\";\r\nimport {SC_Event_FileMenu} from \"./SC_Event_FileMenu\";\r\nimport {SC_Event_FolderMenu} from \"./SC_Event_FolderMenu\";\r\nimport {SC_Event_EditorMenu} from \"./SC_Event_EditorMenu\";\r\nimport {SC_Event_FileCreated} from \"./SC_Event_FileCreated\";\r\nimport {SC_Event_FileDeleted} from \"./SC_Event_FileDeleted\";\r\nimport {SC_Event_FileContentModified} from \"./SC_Event_FileContentModified\";\r\nimport {SC_Event_FileMoved} from \"./SC_Event_FileMoved\";\r\nimport {SC_Event_FileRenamed} from \"./SC_Event_FileRenamed\";\r\nimport {SC_Event_FolderCreated} from \"./SC_Event_FolderCreated\";\r\nimport {SC_Event_FolderDeleted} from \"./SC_Event_FolderDeleted\";\r\nimport {SC_Event_FolderMoved} from \"./SC_Event_FolderMoved\";\r\nimport {SC_Event_FolderRenamed} from \"./SC_Event_FolderRenamed\";\r\nimport {SC_Event} from \"./SC_Event\";\r\n\r\nexport function getSC_Events(plugin: SC_Plugin) {\r\n    if (eventList.length === 0) {\r\n        // Cache the list of SC_Event objects\r\n        eventList.push(\r\n            new SC_Event_onLayoutReady(plugin),\r\n            new SC_Event_onQuit(plugin),\r\n            new SC_Event_onActiveLeafChanged(plugin),\r\n            new SC_Event_EveryNSeconds(plugin),\r\n            new SC_Event_FileMenu(plugin),\r\n            new SC_Event_FolderMenu(plugin),\r\n            new SC_Event_EditorMenu(plugin),\r\n            new SC_Event_FileContentModified(plugin),\r\n            new SC_Event_FileCreated(plugin),\r\n            new SC_Event_FileDeleted(plugin),\r\n            new SC_Event_FileMoved(plugin),\r\n            new SC_Event_FileRenamed(plugin),\r\n            new SC_Event_FolderCreated(plugin),\r\n            new SC_Event_FolderDeleted(plugin),\r\n            new SC_Event_FolderMoved(plugin),\r\n            new SC_Event_FolderRenamed(plugin),\r\n        );\r\n    }\r\n    return eventList;\r\n}\r\nconst eventList: SC_Event[] = [];\r\n\r\nexport function getSC_Event(plugin: SC_Plugin, sc_event_class: typeof SC_Event): SC_Event | undefined {\r\n    let found_sc_event: SC_Event | undefined = undefined;\r\n    getSC_Events(plugin).forEach((sc_event: SC_Event) => {\r\n        if (sc_event instanceof sc_event_class) {\r\n            found_sc_event = sc_event;\r\n        }\r\n    });\r\n    return found_sc_event;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {setIcon} from \"obsidian\";\r\nimport {uniqueArray} from \"./Common\";\r\n\r\n/**\r\n * A wrapper for Obsidian's setIcon(), but with the difference that this one does not need a container as a parameter.\r\n */\r\nexport function getIconHTML(icon_id: string) {\r\n    if (!icon_id) {\r\n        return \"\";\r\n    }\r\n    const icon_container = document.body.createEl(\"div\"); // A temporary element, will be deleted soon. Not nice to create a temporary element in the body, but I don't know any better way.\r\n    setIcon(icon_container, icon_id);\r\n    const icon_html = icon_container.innerHTML;\r\n    icon_container.remove();\r\n    return icon_html;\r\n}\r\n\r\n/**\r\n * @author The list is provided by phibr0.\r\n * @link https://discord.com/channels/686053708261228577/840286264964022302/968248588641665075\r\n * @description phibr0: \"Updated Icon List for Obsidian v0.14.7+ (lucide icons v0.30.0 + obsidians own)\"\r\n * @copyright The copyright statement at the top of this file does not affect this list of icons.\r\n * TODO: The list seems to miss some icons, at least 'gear'.\r\n */\r\nexport const ICON_LIST = [\"activity\",\"airplay\",\"alarm-check\",\"alarm-clock-off\",\"alarm-clock\",\"alarm-minus\",\"alarm-plus\",\"album\",\"alert-circle\",\"alert-octagon\",\"alert-triangle\",\"align-center-horizontal\",\"align-center-vertical\",\"align-center\",\"align-end-horizontal\",\"align-end-vertical\",\"align-horizontal-distribute-center\",\"align-horizontal-distribute-end\",\"align-horizontal-distribute-start\",\"align-horizontal-justify-center\",\"align-horizontal-justify-end\",\"align-horizontal-justify-start\",\"align-horizontal-space-around\",\"align-horizontal-space-between\",\"align-justify\",\"align-left\",\"align-right\",\"align-start-horizontal\",\"align-start-vertical\",\"align-vertical-distribute-center\",\"align-vertical-distribute-end\",\"align-vertical-distribute-start\",\"align-vertical-justify-center\",\"align-vertical-justify-end\",\"align-vertical-justify-start\",\"align-vertical-space-around\",\"align-vertical-space-between\",\"anchor\",\"aperture\",\"archive\",\"arrow-big-down\",\"arrow-big-left\",\"arrow-big-right\",\"arrow-big-up\",\"arrow-down-circle\",\"arrow-down-left\",\"arrow-down-right\",\"arrow-down\",\"arrow-left-circle\",\"arrow-left-right\",\"arrow-left\",\"arrow-right-circle\",\"arrow-right\",\"arrow-up-circle\",\"arrow-up-left\",\"arrow-up-right\",\"arrow-up\",\"asterisk\",\"at-sign\",\"award\",\"axe\",\"banknote\",\"bar-chart-2\",\"bar-chart\",\"baseline\",\"battery-charging\",\"battery-full\",\"battery-low\",\"battery-medium\",\"battery\",\"beaker\",\"bell-minus\",\"bell-off\",\"bell-plus\",\"bell-ring\",\"bell\",\"bike\",\"binary\",\"bitcoin\",\"bluetooth-connected\",\"bluetooth-off\",\"bluetooth-searching\",\"bluetooth\",\"bold\",\"book-open\",\"book\",\"bookmark-minus\",\"bookmark-plus\",\"bookmark\",\"bot\",\"box-select\",\"box\",\"briefcase\",\"brush\",\"bug\",\"building-2\",\"building\",\"bus\",\"calculator\",\"calendar\",\"camera-off\",\"camera\",\"car\",\"carrot\",\"cast\",\"check-circle-2\",\"check-circle\",\"check-square\",\"check\",\"chevron-down\",\"chevron-first\",\"chevron-last\",\"chevron-left\",\"chevron-right\",\"chevron-up\",\"chevrons-down-up\",\"chevrons-down\",\"chevrons-left\",\"chevrons-right\",\"chevrons-up-down\",\"chevrons-up\",\"chrome\",\"circle-slashed\",\"circle\",\"clipboard-check\",\"clipboard-copy\",\"clipboard-list\",\"clipboard-x\",\"clipboard\",\"clock-1\",\"clock-10\",\"clock-11\",\"clock-12\",\"clock-2\",\"clock-3\",\"clock-4\",\"clock-5\",\"clock-6\",\"clock-7\",\"clock-8\",\"clock-9\",\"clock\",\"cloud-drizzle\",\"cloud-fog\",\"cloud-hail\",\"cloud-lightning\",\"cloud-moon\",\"cloud-off\",\"cloud-rain-wind\",\"cloud-rain\",\"cloud-snow\",\"cloud-sun\",\"cloud\",\"cloudy\",\"clover\",\"code-2\",\"code\",\"codepen\",\"codesandbox\",\"coffee\",\"coins\",\"columns\",\"command\",\"compass\",\"contact\",\"contrast\",\"cookie\",\"copy\",\"copyleft\",\"copyright\",\"corner-down-left\",\"corner-down-right\",\"corner-left-down\",\"corner-left-up\",\"corner-right-down\",\"corner-right-up\",\"corner-up-left\",\"corner-up-right\",\"cpu\",\"credit-card\",\"crop\",\"cross\",\"crosshair\",\"crown\",\"currency\",\"database\",\"delete\",\"dice-1\",\"dice-2\",\"dice-3\",\"dice-4\",\"dice-5\",\"dice-6\",\"disc\",\"divide-circle\",\"divide-square\",\"divide\",\"dollar-sign\",\"download-cloud\",\"download\",\"dribbble\",\"droplet\",\"droplets\",\"drumstick\",\"edit-2\",\"edit-3\",\"edit\",\"egg\",\"equal-not\",\"equal\",\"eraser\",\"euro\",\"expand\",\"external-link\",\"eye-off\",\"eye\",\"facebook\",\"fast-forward\",\"feather\",\"figma\",\"file-check-2\",\"file-check\",\"file-code\",\"file-digit\",\"file-input\",\"file-minus-2\",\"file-minus\",\"file-output\",\"file-plus-2\",\"file-plus\",\"file-search\",\"file-text\",\"file-x-2\",\"file-x\",\"file\",\"files\",\"film\",\"filter\",\"flag-off\",\"flag-triangle-left\",\"flag-triangle-right\",\"flag\",\"flame\",\"flashlight-off\",\"flashlight\",\"flask-conical\",\"flask-round\",\"folder-minus\",\"folder-open\",\"folder-plus\",\"folder\",\"form-input\",\"forward\",\"frame\",\"framer\",\"frown\",\"function-square\",\"gamepad-2\",\"gamepad\",\"gauge\",\"gavel\",\"gem\",\"ghost\",\"gift\",\"git-branch-plus\",\"git-branch\",\"git-commit\",\"git-fork\",\"git-merge\",\"git-pull-request\",\"github\",\"gitlab\",\"glasses\",\"globe-2\",\"globe\",\"grab\",\"graduation-cap\",\"grid\",\"grip-horizontal\",\"grip-vertical\",\"hammer\",\"hand-metal\",\"hand\",\"hard-drive\",\"hard-hat\",\"hash\",\"haze\",\"headphones\",\"heart\",\"help-circle\",\"hexagon\",\"highlighter\",\"history\",\"home\",\"image-minus\",\"image-off\",\"image-plus\",\"image\",\"import\",\"inbox\",\"indent\",\"indian-rupee\",\"infinity\",\"info\",\"inspect\",\"instagram\",\"italic\",\"japanese-yen\",\"key\",\"keyboard\",\"landmark\",\"languages\",\"laptop-2\",\"laptop\",\"lasso-select\",\"lasso\",\"layers\",\"layout-dashboard\",\"layout-grid\",\"layout-list\",\"layout-template\",\"layout\",\"library\",\"life-buoy\",\"lightbulb-off\",\"lightbulb\",\"link-2-off\",\"link-2\",\"link\",\"linkedin\",\"list-checks\",\"list-minus\",\"list-ordered\",\"list-plus\",\"list-x\",\"list\",\"loader-2\",\"loader\",\"locate-fixed\",\"locate-off\",\"locate\",\"lock\",\"log-in\",\"log-out\",\"mail\",\"map-pin\",\"map\",\"maximize-2\",\"maximize\",\"megaphone\",\"meh\",\"menu\",\"message-circle\",\"message-square\",\"mic-off\",\"mic\",\"minimize-2\",\"minimize\",\"minus-circle\",\"minus-square\",\"minus\",\"monitor-off\",\"monitor-speaker\",\"monitor\",\"moon\",\"more-horizontal\",\"more-vertical\",\"mountain-snow\",\"mountain\",\"mouse-pointer-2\",\"mouse-pointer-click\",\"mouse-pointer\",\"mouse\",\"move-diagonal-2\",\"move-diagonal\",\"move-horizontal\",\"move-vertical\",\"move\",\"music\",\"navigation-2\",\"navigation\",\"network\",\"octagon\",\"option\",\"outdent\",\"package-check\",\"package-minus\",\"package-plus\",\"package-search\",\"package-x\",\"package\",\"palette\",\"palmtree\",\"paperclip\",\"pause-circle\",\"pause-octagon\",\"pause\",\"pen-tool\",\"pencil\",\"percent\",\"person-standing\",\"phone-call\",\"phone-forwarded\",\"phone-incoming\",\"phone-missed\",\"phone-off\",\"phone-outgoing\",\"phone\",\"pie-chart\",\"piggy-bank\",\"pin\",\"pipette\",\"plane\",\"play-circle\",\"play\",\"plug-zap\",\"plus-circle\",\"plus-square\",\"plus\",\"pocket\",\"podcast\",\"pointer\",\"pound-sterling\",\"power-off\",\"power\",\"printer\",\"qr-code\",\"quote\",\"radio-receiver\",\"radio\",\"redo\",\"refresh-ccw\",\"refresh-cw\",\"regex\",\"repeat-1\",\"repeat\",\"reply-all\",\"reply\",\"rewind\",\"rocket\",\"rocking-chair\",\"rotate-ccw\",\"rotate-cw\",\"rss\",\"ruler\",\"russian-ruble\",\"save\",\"scale\",\"scan-line\",\"scan\",\"scissors\",\"screen-share-off\",\"screen-share\",\"search\",\"send\",\"separator-horizontal\",\"separator-vertical\",\"server-crash\",\"server-off\",\"server\",\"settings-2\",\"settings\",\"share-2\",\"share\",\"sheet\",\"shield-alert\",\"shield-check\",\"shield-close\",\"shield-off\",\"shield\",\"shirt\",\"shopping-bag\",\"shopping-cart\",\"shovel\",\"shrink\",\"shuffle\",\"sidebar-close\",\"sidebar-open\",\"sidebar\",\"sigma\",\"signal-high\",\"signal-low\",\"signal-medium\",\"signal-zero\",\"signal\",\"skip-back\",\"skip-forward\",\"skull\",\"slack\",\"slash\",\"sliders\",\"smartphone-charging\",\"smartphone\",\"smile\",\"snowflake\",\"sort-asc\",\"sort-desc\",\"speaker\",\"sprout\",\"square\",\"star-half\",\"star\",\"stop-circle\",\"stretch-horizontal\",\"stretch-vertical\",\"strikethrough\",\"subscript\",\"sun\",\"sunrise\",\"sunset\",\"superscript\",\"swiss-franc\",\"switch-camera\",\"table\",\"tablet\",\"tag\",\"target\",\"tent\",\"terminal-square\",\"terminal\",\"text-cursor-input\",\"text-cursor\",\"thermometer-snowflake\",\"thermometer-sun\",\"thermometer\",\"thumbs-down\",\"thumbs-up\",\"ticket\",\"timer-off\",\"timer-reset\",\"timer\",\"toggle-left\",\"toggle-right\",\"tornado\",\"trash-2\",\"trash\",\"trello\",\"trending-down\",\"trending-up\",\"triangle\",\"truck\",\"tv-2\",\"tv\",\"twitch\",\"twitter\",\"type\",\"umbrella\",\"underline\",\"undo\",\"unlink-2\",\"unlink\",\"unlock\",\"upload-cloud\",\"upload\",\"user-check\",\"user-minus\",\"user-plus\",\"user-x\",\"user\",\"users\",\"verified\",\"vibrate\",\"video-off\",\"video\",\"view\",\"voicemail\",\"volume-1\",\"volume-2\",\"volume-x\",\"volume\",\"wallet\",\"wand\",\"watch\",\"waves\",\"webcam\",\"wifi-off\",\"wifi\",\"wind\",\"wrap-text\",\"wrench\",\"x-circle\",\"x-octagon\",\"x-square\",\"x\",\"youtube\",\"zap-off\",\"zap\",\"zoom-in\",\"zoom-out\",\"search-large\",\"search\",\"activity\",\"airplay\",\"alarm-check\",\"alarm-clock-off\",\"alarm-clock\",\"alarm-minus\",\"alarm-plus\",\"album\",\"alert-circle\",\"alert-octagon\",\"alert-triangle\",\"align-center-horizontal\",\"align-center-vertical\",\"align-center\",\"align-end-horizontal\",\"align-end-vertical\",\"align-horizontal-distribute-center\",\"align-horizontal-distribute-end\",\"align-horizontal-distribute-start\",\"align-horizontal-justify-center\",\"align-horizontal-justify-end\",\"align-horizontal-justify-start\",\"align-horizontal-space-around\",\"align-horizontal-space-between\",\"align-justify\",\"align-left\",\"align-right\",\"align-start-horizontal\",\"align-start-vertical\",\"align-vertical-distribute-center\",\"align-vertical-distribute-end\",\"align-vertical-distribute-start\",\"align-vertical-justify-center\",\"align-vertical-justify-end\",\"align-vertical-justify-start\",\"align-vertical-space-around\",\"align-vertical-space-between\",\"anchor\",\"aperture\",\"archive\",\"arrow-big-down\",\"arrow-big-left\",\"arrow-big-right\",\"arrow-big-up\",\"arrow-down-circle\",\"arrow-down-left\",\"arrow-down-right\",\"arrow-down\",\"arrow-left-circle\",\"arrow-left-right\",\"arrow-left\",\"arrow-right-circle\",\"arrow-right\",\"arrow-up-circle\",\"arrow-up-left\",\"arrow-up-right\",\"arrow-up\",\"asterisk\",\"at-sign\",\"award\",\"axe\",\"banknote\",\"bar-chart-2\",\"bar-chart\",\"baseline\",\"battery-charging\",\"battery-full\",\"battery-low\",\"battery-medium\",\"battery\",\"beaker\",\"bell-minus\",\"bell-off\",\"bell-plus\",\"bell-ring\",\"bell\",\"bike\",\"binary\",\"bitcoin\",\"bluetooth-connected\",\"bluetooth-off\",\"bluetooth-searching\",\"bluetooth\",\"bold\",\"book-open\",\"book\",\"bookmark-minus\",\"bookmark-plus\",\"bookmark\",\"bot\",\"box-select\",\"box\",\"briefcase\",\"brush\",\"bug\",\"building-2\",\"building\",\"bus\",\"calculator\",\"calendar\",\"camera-off\",\"camera\",\"car\",\"carrot\",\"cast\",\"check-circle-2\",\"check-circle\",\"check-square\",\"check\",\"chevron-down\",\"chevron-first\",\"chevron-last\",\"chevron-left\",\"chevron-right\",\"chevron-up\",\"chevrons-down-up\",\"chevrons-down\",\"chevrons-left\",\"chevrons-right\",\"chevrons-up-down\",\"chevrons-up\",\"chrome\",\"circle-slashed\",\"circle\",\"clipboard-check\",\"clipboard-copy\",\"clipboard-list\",\"clipboard-x\",\"clipboard\",\"clock-1\",\"clock-10\",\"clock-11\",\"clock-12\",\"clock-2\",\"clock-3\",\"clock-4\",\"clock-5\",\"clock-6\",\"clock-7\",\"clock-8\",\"clock-9\",\"lucide-clock\",\"cloud-drizzle\",\"cloud-fog\",\"cloud-hail\",\"cloud-lightning\",\"cloud-moon\",\"cloud-off\",\"cloud-rain-wind\",\"cloud-rain\",\"cloud-snow\",\"cloud-sun\",\"lucide-cloud\",\"cloudy\",\"clover\",\"code-2\",\"code\",\"codepen\",\"codesandbox\",\"coffee\",\"coins\",\"columns\",\"command\",\"compass\",\"contact\",\"contrast\",\"cookie\",\"copy\",\"copyleft\",\"copyright\",\"corner-down-left\",\"corner-down-right\",\"corner-left-down\",\"corner-left-up\",\"corner-right-down\",\"corner-right-up\",\"corner-up-left\",\"corner-up-right\",\"cpu\",\"credit-card\",\"crop\",\"lucide-cross\",\"crosshair\",\"crown\",\"currency\",\"database\",\"delete\",\"dice-1\",\"dice-2\",\"dice-3\",\"dice-4\",\"dice-5\",\"dice-6\",\"disc\",\"divide-circle\",\"divide-square\",\"divide\",\"dollar-sign\",\"download-cloud\",\"download\",\"dribbble\",\"droplet\",\"droplets\",\"drumstick\",\"edit-2\",\"edit-3\",\"edit\",\"egg\",\"equal-not\",\"equal\",\"eraser\",\"euro\",\"expand\",\"external-link\",\"eye-off\",\"eye\",\"facebook\",\"fast-forward\",\"feather\",\"figma\",\"file-check-2\",\"file-check\",\"file-code\",\"file-digit\",\"file-input\",\"file-minus-2\",\"file-minus\",\"file-output\",\"file-plus-2\",\"file-plus\",\"file-search\",\"file-text\",\"file-x-2\",\"file-x\",\"file\",\"files\",\"film\",\"filter\",\"flag-off\",\"flag-triangle-left\",\"flag-triangle-right\",\"flag\",\"flame\",\"flashlight-off\",\"flashlight\",\"flask-conical\",\"flask-round\",\"folder-minus\",\"folder-open\",\"folder-plus\",\"lucide-folder\",\"form-input\",\"forward\",\"frame\",\"framer\",\"frown\",\"function-square\",\"gamepad-2\",\"gamepad\",\"gauge\",\"gavel\",\"gem\",\"ghost\",\"gift\",\"git-branch-plus\",\"git-branch\",\"git-commit\",\"git-fork\",\"git-merge\",\"git-pull-request\",\"github\",\"gitlab\",\"glasses\",\"globe-2\",\"globe\",\"grab\",\"graduation-cap\",\"grid\",\"grip-horizontal\",\"grip-vertical\",\"hammer\",\"hand-metal\",\"hand\",\"hard-drive\",\"hard-hat\",\"hash\",\"haze\",\"headphones\",\"heart\",\"help-circle\",\"hexagon\",\"highlighter\",\"history\",\"home\",\"image-minus\",\"image-off\",\"image-plus\",\"image\",\"import\",\"inbox\",\"indent\",\"indian-rupee\",\"infinity\",\"lucide-info\",\"inspect\",\"instagram\",\"italic\",\"japanese-yen\",\"key\",\"keyboard\",\"landmark\",\"lucide-languages\",\"laptop-2\",\"laptop\",\"lasso-select\",\"lasso\",\"layers\",\"layout-dashboard\",\"layout-grid\",\"layout-list\",\"layout-template\",\"layout\",\"library\",\"life-buoy\",\"lightbulb-off\",\"lightbulb\",\"link-2-off\",\"link-2\",\"lucide-link\",\"linkedin\",\"list-checks\",\"list-minus\",\"list-ordered\",\"list-plus\",\"list-x\",\"list\",\"loader-2\",\"loader\",\"locate-fixed\",\"locate-off\",\"locate\",\"lock\",\"log-in\",\"log-out\",\"mail\",\"map-pin\",\"map\",\"maximize-2\",\"maximize\",\"megaphone\",\"meh\",\"menu\",\"message-circle\",\"message-square\",\"mic-off\",\"mic\",\"minimize-2\",\"minimize\",\"minus-circle\",\"minus-square\",\"minus\",\"monitor-off\",\"monitor-speaker\",\"monitor\",\"moon\",\"more-horizontal\",\"more-vertical\",\"mountain-snow\",\"mountain\",\"mouse-pointer-2\",\"mouse-pointer-click\",\"mouse-pointer\",\"mouse\",\"move-diagonal-2\",\"move-diagonal\",\"move-horizontal\",\"move-vertical\",\"move\",\"music\",\"navigation-2\",\"navigation\",\"network\",\"octagon\",\"option\",\"outdent\",\"package-check\",\"package-minus\",\"package-plus\",\"package-search\",\"package-x\",\"package\",\"palette\",\"palmtree\",\"paperclip\",\"pause-circle\",\"pause-octagon\",\"pause\",\"pen-tool\",\"lucide-pencil\",\"percent\",\"person-standing\",\"phone-call\",\"phone-forwarded\",\"phone-incoming\",\"phone-missed\",\"phone-off\",\"phone-outgoing\",\"phone\",\"pie-chart\",\"piggy-bank\",\"lucide-pin\",\"pipette\",\"plane\",\"play-circle\",\"play\",\"plug-zap\",\"plus-circle\",\"plus-square\",\"plus\",\"pocket\",\"podcast\",\"pointer\",\"pound-sterling\",\"power-off\",\"power\",\"printer\",\"qr-code\",\"quote\",\"radio-receiver\",\"radio\",\"redo\",\"refresh-ccw\",\"refresh-cw\",\"regex\",\"repeat-1\",\"repeat\",\"reply-all\",\"reply\",\"rewind\",\"rocket\",\"rocking-chair\",\"rotate-ccw\",\"rotate-cw\",\"rss\",\"ruler\",\"russian-ruble\",\"save\",\"scale\",\"scan-line\",\"scan\",\"scissors\",\"screen-share-off\",\"screen-share\",\"lucide-search\",\"send\",\"separator-horizontal\",\"separator-vertical\",\"server-crash\",\"server-off\",\"server\",\"settings-2\",\"settings\",\"share-2\",\"share\",\"sheet\",\"shield-alert\",\"shield-check\",\"shield-close\",\"shield-off\",\"shield\",\"shirt\",\"shopping-bag\",\"shopping-cart\",\"shovel\",\"shrink\",\"shuffle\",\"sidebar-close\",\"sidebar-open\",\"sidebar\",\"sigma\",\"signal-high\",\"signal-low\",\"signal-medium\",\"signal-zero\",\"signal\",\"skip-back\",\"skip-forward\",\"skull\",\"slack\",\"slash\",\"sliders\",\"smartphone-charging\",\"smartphone\",\"smile\",\"snowflake\",\"sort-asc\",\"sort-desc\",\"speaker\",\"sprout\",\"square\",\"star-half\",\"lucide-star\",\"stop-circle\",\"stretch-horizontal\",\"stretch-vertical\",\"strikethrough\",\"subscript\",\"sun\",\"sunrise\",\"sunset\",\"superscript\",\"swiss-franc\",\"switch-camera\",\"table\",\"tablet\",\"tag\",\"target\",\"tent\",\"terminal-square\",\"terminal\",\"text-cursor-input\",\"text-cursor\",\"thermometer-snowflake\",\"thermometer-sun\",\"thermometer\",\"thumbs-down\",\"thumbs-up\",\"ticket\",\"timer-off\",\"timer-reset\",\"timer\",\"toggle-left\",\"toggle-right\",\"tornado\",\"trash-2\",\"lucide-trash\",\"trello\",\"trending-down\",\"trending-up\",\"triangle\",\"truck\",\"tv-2\",\"tv\",\"twitch\",\"twitter\",\"type\",\"umbrella\",\"underline\",\"undo\",\"unlink-2\",\"unlink\",\"unlock\",\"upload-cloud\",\"upload\",\"user-check\",\"user-minus\",\"user-plus\",\"user-x\",\"user\",\"users\",\"verified\",\"vibrate\",\"video-off\",\"video\",\"view\",\"voicemail\",\"volume-1\",\"volume-2\",\"volume-x\",\"volume\",\"wallet\",\"wand\",\"watch\",\"waves\",\"webcam\",\"wifi-off\",\"wifi\",\"wind\",\"wrap-text\",\"wrench\",\"x-circle\",\"x-octagon\",\"x-square\",\"x\",\"youtube\",\"zap-off\",\"zap\",\"zoom-in\",\"zoom-out\",\"search-large\",\"lucide-search\"];\r\n\r\n/**\r\n * The original ICON_LIST contains duplicate entries (e.g. two \"activity\" items) and is not in alphabetical order. This list improves it.\r\n */\r\nexport const ICON_LIST_SORTED_UNIQUE = uniqueArray(ICON_LIST).sort();","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {ShellCommandConfiguration} from \"./settings/ShellCommandConfiguration\";\r\nimport SC_Plugin from \"./main\";\r\nimport {\r\n    generateObsidianCommandName,\r\n    getOperatingSystem,\r\n    mergeSets,\r\n    removeFromSet,\r\n} from \"./Common\";\r\nimport {SC_Event} from \"./events/SC_Event\";\r\nimport {getSC_Events} from \"./events/SC_EventList\";\r\nimport {debugLog} from \"./Debug\";\r\nimport {Command} from \"obsidian\";\r\nimport {VariableSet} from \"./variables/loadVariables\";\r\nimport {getUsedVariables} from \"./variables/parseVariables\";\r\nimport {\r\n    createPreaction,\r\n    CustomVariable,\r\n    getIDGenerator,\r\n    getPATHAugmentation,\r\n    ParsingProcess,\r\n    Preaction,\r\n    PreactionConfiguration\r\n} from \"./imports\";\r\nimport {\r\n    Variable,\r\n    InheritableVariableDefaultValueConfiguration,\r\n} from \"./variables/Variable\";\r\nimport {\r\n    PlatformId,\r\n    PlatformNames,\r\n} from \"./settings/SC_MainSettings\";\r\nimport {getIconHTML} from \"./Icons\";\r\nimport {OutputStream} from \"./output_channels/OutputChannelCode\";\r\nimport {OutputWrapper} from \"./models/output_wrapper/OutputWrapper\";\r\n\r\nexport interface TShellCommandContainer {\r\n    [key: string]: TShellCommand,\r\n}\r\n\r\n/**\r\n * TODO: Rename this class. Replace the T prefix with something else. The T stands for Type (kind of like TFile from Obsidian), but this is not a type, this is a class. Maybe ShellCommandInstance? It's not the best name, but I can't come up with a better one now.\r\n */\r\nexport class TShellCommand {\r\n\r\n    private plugin: SC_Plugin;\r\n    private configuration: ShellCommandConfiguration;\r\n    private obsidian_command: Command;\r\n\r\n    constructor (plugin: SC_Plugin, configuration: ShellCommandConfiguration) {\r\n        this.plugin = plugin;\r\n        this.configuration = configuration;\r\n\r\n        // Introduce the ID to an ID generator so that it won't accidentally generate the same ID again when creating new shell commands.\r\n        getIDGenerator().addReservedID(configuration.id);\r\n    }\r\n\r\n    public getPlugin() {\r\n        return this.plugin;\r\n    }\r\n    /**\r\n     * Use this when you need to alter the configuration values. if you only need to read configuration values, use get*()\r\n     * methods instead.\r\n     */\r\n    public getConfiguration() {\r\n        return this.configuration;\r\n    }\r\n\r\n    public getId() {\r\n        return this.configuration.id;\r\n    }\r\n\r\n    public getShell(): string {\r\n        // Check if the shell command has defined a specific shell.\r\n        const shell: string | undefined = this.configuration.shells[getOperatingSystem()];\r\n        if (undefined === shell) {\r\n            // The shell command does not define an explicit shell.\r\n            // Use a default shell from the plugin's settings.\r\n            return this.plugin.getDefaultShell();\r\n        } else {\r\n            // The shell command has an explicit shell defined.\r\n            return shell;\r\n        }\r\n    }\r\n\r\n    public getShells() {\r\n        return this.configuration.shells;\r\n    }\r\n\r\n    /**\r\n     * Returns a shell command string specific for the current operating system, or a generic shell command if this shell\r\n     * command does not have an explicit version for the current OS.\r\n     */\r\n    public getShellCommand(): string {\r\n        // Check if the shell command has defined a specific command for this operating system.\r\n        const platformSpecificShellCommand: string | undefined = this.configuration.platform_specific_commands[getOperatingSystem()];\r\n        if (undefined === platformSpecificShellCommand) {\r\n            // No command is defined specifically for this operating system.\r\n            // Return an \"OS agnostic\" command.\r\n            return this.configuration.platform_specific_commands.default;\r\n        } else {\r\n            // The shell command has defined a specific command for this operating system.\r\n            return platformSpecificShellCommand;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns a version of the shell command that should be used if no platform specific command is defined for the\r\n     * current platform. If you plan to use this for execution, consider using getShellCommand() instead, as it takes the\r\n     * current platform into account.\r\n     */\r\n    public getDefaultShellCommand() {\r\n        return this.configuration.platform_specific_commands.default;\r\n    }\r\n\r\n    public getPlatformSpecificShellCommands() {\r\n        return this.configuration.platform_specific_commands;\r\n    }\r\n\r\n    /**\r\n     * Returns a list of PlatformIds that have a shell command version defined. 'default' is never included in the list.\r\n     *\r\n     * TODO: Invent a better name for this method.\r\n     */\r\n    public getNonEmptyPlatformIds() {\r\n        const platform_specific_shell_commands = this.getPlatformSpecificShellCommands();\r\n        const platform_ids_with_non_empty_shell_commands: PlatformId[] = [];\r\n        let platform_id: PlatformId;\r\n        for (platform_id in PlatformNames) { // Note that this loop does not iterate 'default' platform id (= the fallback platform id that is used when a shell command does not have a version for the current platform).\r\n            const platform_specific_shell_command = platform_specific_shell_commands[platform_id as PlatformId];\r\n            if (platform_specific_shell_command && \"\" !== platform_specific_shell_command.trim()) {\r\n                platform_ids_with_non_empty_shell_commands.push(platform_id);\r\n            }\r\n        }\r\n        return platform_ids_with_non_empty_shell_commands;\r\n    }\r\n\r\n    public getIconId() {\r\n        return this.configuration.icon;\r\n    }\r\n\r\n    public getIconHTML() {\r\n        if (this.configuration.icon) {\r\n            // An icon is defined.\r\n            return getIconHTML(this.configuration.icon);\r\n        } else {\r\n            // No icon is defined.\r\n            return \"\";\r\n        }\r\n    }\r\n\r\n    public getAlias() {\r\n        return this.configuration.alias;\r\n    }\r\n\r\n    /**\r\n     * TODO: Use this method in all places where similar logic is needed.\r\n     */\r\n    public getAliasOrShellCommand(): string {\r\n        return this.configuration.alias || this.getShellCommand();\r\n    }\r\n\r\n    public getConfirmExecution() {\r\n        return this.configuration.confirm_execution;\r\n    }\r\n\r\n    public getIgnoreErrorCodes() {\r\n        return this.configuration.ignore_error_codes;\r\n    }\r\n\r\n    public getInputChannels() {\r\n        return this.configuration.input_contents;\r\n    }\r\n\r\n    public getOutputChannelOrder() {\r\n        return this.configuration.output_channel_order;\r\n    }\r\n\r\n    public getOutputChannels() {\r\n        return this.configuration.output_channels;\r\n    }\r\n\r\n    public getOutputHandlingMode() {\r\n        return this.configuration.output_handling_mode;\r\n    }\r\n\r\n    /**\r\n     * Finds an output wrapper that should be used for the given OutputStream. Returns null, if no OutputWrapper should\r\n     * be used.\r\n     *\r\n     * @param output_stream\r\n     */\r\n    public getOutputWrapper(output_stream: OutputStream): OutputWrapper | null {\r\n        const output_wrapper_id = this.configuration.output_wrappers[output_stream];\r\n        if (!output_wrapper_id) {\r\n            // No output wrapper is defined for this output stream in this shell command.\r\n            return null;\r\n        }\r\n        for (const output_wrapper of this.plugin.getOutputWrappers().values()) {\r\n            // Check if this is the output wrapper defined for this shell command.\r\n            if (output_wrapper.getID() === output_wrapper_id) {\r\n                // The correct output wrapper was found.\r\n                return output_wrapper;\r\n            }\r\n        }\r\n        throw new Error(\"OutputWrapper with ID \" + output_wrapper_id + \" was not found.\");\r\n    }\r\n\r\n    /**\r\n     * Checks if different output streams can be wrapped together. In addition to this, combining output streams also\r\n     * requires the OutputChannels to be the same, but that's not checked in this method.\r\n     */\r\n    public isOutputWrapperStdoutSameAsStderr() {\r\n        return this.configuration.output_wrappers[\"stdout\"] === this.configuration.output_wrappers[\"stderr\"];\r\n    }\r\n\r\n    public getEventsConfiguration() {\r\n        return this.configuration.events;\r\n    }\r\n\r\n    public getEventConfiguration(sc_event: SC_Event) {\r\n        return this.getEventsConfiguration()[sc_event.static().getCode()] || sc_event.getDefaultConfiguration(false);\r\n    }\r\n\r\n    public isSC_EventEnabled(event_code: string) {\r\n        const events_configuration =  this.getEventsConfiguration();\r\n        if (undefined === events_configuration[event_code]) {\r\n            // Not enabled\r\n            return false;\r\n        } else {\r\n            // Maybe enabled\r\n            return events_configuration[event_code].enabled;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Called when changing event settings in ShellCommandExtraOptionsModal.\r\n     * plugin.saveSettings() needs to be called after this!\r\n     *\r\n     * @param sc_event\r\n     */\r\n    public enableSC_Event(sc_event: SC_Event) {\r\n        const event_code = sc_event.static().getCode();\r\n        const events_configuration =  this.getEventsConfiguration();\r\n        if (undefined === events_configuration[event_code]) {\r\n            // Not enabled\r\n            // Enable\r\n            events_configuration[event_code] = sc_event.getDefaultConfiguration(true);\r\n        } else {\r\n            // Maybe enabled\r\n            if (!events_configuration[event_code].enabled) {\r\n                events_configuration[event_code].enabled = true;\r\n            }\r\n        }\r\n        if (sc_event.canRegisterAfterChangingSettings()) {\r\n            this.registerSC_Event(sc_event);\r\n        }\r\n        sc_event.onAfterEnabling(this);\r\n    }\r\n\r\n    /**\r\n     * Called when changing event settings in ShellCommandExtraOptionsModal.\r\n     * plugin.saveSettings() needs to be called after this!\r\n     *\r\n     * @param sc_event\r\n     */\r\n    public disableSC_Event(sc_event: SC_Event) {\r\n        const event_code = sc_event.static().getCode();\r\n        const events_configuration =  this.getEventsConfiguration();\r\n        if (undefined !== events_configuration[event_code]) {\r\n            // Maybe enabled\r\n            if (events_configuration[event_code].enabled) {\r\n                // Is enabled.\r\n                // Disable.\r\n                const configuration_property_names = Object.getOwnPropertyNames(events_configuration[event_code]);\r\n                if (configuration_property_names.length > 1) {\r\n                    // There's more settings than just 'enable'.\r\n                    // Disable by setting 'enable' to false, don't flush the settings, they can be useful if the event gets re-enabled.\r\n                    events_configuration[event_code].enabled = false;\r\n                } else {\r\n                    // 'enabled' is the only setting.\r\n                    // Disable by removing the configuration object completely to make the settings file cleaner.\r\n                    delete events_configuration[event_code];\r\n                }\r\n            }\r\n        }\r\n        if (sc_event.canRegisterAfterChangingSettings()) {\r\n            this.unregisterSC_Event(sc_event);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns all SC_Events that are enabled fro this shell command.\r\n     *\r\n     * Private as it's currently only used domestically, but can be changed to public if needed.\r\n     */\r\n    private getSC_Events(): SC_Event[] {\r\n        const enabled_sc_events: SC_Event[] = [];\r\n        getSC_Events(this.plugin).forEach((sc_event: SC_Event) => {\r\n            if (this.isSC_EventEnabled(sc_event.static().getCode())) {\r\n                enabled_sc_events.push(sc_event);\r\n            }\r\n        });\r\n        return enabled_sc_events;\r\n    }\r\n\r\n    /**\r\n     * Private, if you need access from outside, use enableSC_Event().\r\n     *\r\n     * @param sc_event\r\n     * @private\r\n     */\r\n    private registerSC_Event(sc_event: SC_Event) {\r\n        sc_event.register(this);\r\n    }\r\n\r\n    /**\r\n     * Private, if you need access from outside, use disableSC_Event().\r\n     *\r\n     * @param sc_event\r\n     * @private\r\n     */\r\n    private unregisterSC_Event(sc_event: SC_Event) {\r\n        sc_event.unregister(this);\r\n    }\r\n\r\n    /**\r\n     * Set's up all events that are enabled for this shell command.\r\n     *\r\n     * @param called_after_changing_settings Set to: true, if this happens after changing configuration; false, if this happens during loading the plugin.\r\n     */\r\n    public registerSC_Events(called_after_changing_settings: boolean) {\r\n        this.getSC_Events().forEach((sc_event: SC_Event) => {\r\n            const can_register = !called_after_changing_settings || sc_event.canRegisterAfterChangingSettings();\r\n            if (can_register) {\r\n                this.registerSC_Event(sc_event);\r\n            }\r\n        });\r\n    }\r\n\r\n    public unregisterSC_Events() {\r\n        this.getSC_Events().forEach((sc_event: SC_Event) => {\r\n            this.unregisterSC_Event(sc_event);\r\n        });\r\n    }\r\n\r\n    public registerToCommandPalette(): void {\r\n        // TODO: Move the logic from plugin.registerShellCommand() to here, but split to multiple methods.\r\n        this.plugin.registerShellCommand(this);\r\n    }\r\n\r\n    public unregisterFromCommandPalette(): void {\r\n        // FIXME: I think the unregistering does not work.\r\n        delete this.plugin.obsidian_commands[this.getId()];\r\n    }\r\n\r\n    /**\r\n     * Checks the configuration for command_palette_availability and returns:\r\n     *  - true, if the value is \"enabled\" or \"unlisted\"\r\n     *  - false, if the value is \"disabled\"\r\n     *\r\n     * Adding to command palette also enables hotkeys, which is why adding can be permitted, but showing denied, if a shell command should only be available via hotkeys.\r\n     */\r\n    public canAddToCommandPalette(): boolean {\r\n        return this.getConfiguration().command_palette_availability !== \"disabled\";\r\n    }\r\n\r\n    /**\r\n     * Another name for canAddToCommandPalette().\r\n     */\r\n    public canHaveHotkeys(): boolean {\r\n        return this.canAddToCommandPalette();\r\n    }\r\n\r\n    /**\r\n     * Checks the configuration for command_palette_availability and returns:\r\n     *  - true, if the value is \"enabled\"\r\n     *  - false, if the value is \"disabled\" or \"unlisted\"\r\n     */\r\n    public canShowInCommandPalette(): boolean {\r\n        return this.getConfiguration().command_palette_availability === \"enabled\";\r\n    }\r\n\r\n    /**\r\n     * Creates a new ParsingProcess instance and defines two sets of variables:\r\n     *  - First set: All variables that are not tied to any preactions.\r\n     *  - Second set: Variables that are tied to preactions. Can be an empty set.\r\n     * You need to still call ParsingProcess.process() to parse the first set. ShellCommandExecutor takes care of calling\r\n     * ParsingProcess.processRest() to process all non-processed sets.\r\n     *\r\n     * @See ParsingProcess class for a description of the process.\r\n     * @param sc_event Needed to get {{event_*}} variables parsed. Can be left out if working outside any SC_Event context, in which case {{event_*}} variables are inaccessible.\r\n     */\r\n    public createParsingProcess(sc_event: SC_Event | null): ShellCommandParsingProcess {\r\n        const stdout_output_wrapper = this.getOutputWrapper(\"stdout\"); // Can be null\r\n        const stderr_output_wrapper = this.getOutputWrapper(\"stderr\"); // Can be null\r\n        return new ParsingProcess<shell_command_parsing_map>(\r\n            this.plugin,\r\n            {\r\n                shell_command: this.getShellCommand(),\r\n                alias: this.getAlias(),\r\n                environment_variable_path_augmentation: getPATHAugmentation(this.plugin) ?? \"\",\r\n                stdinContent: this.configuration.input_contents.stdin ?? undefined,\r\n                output_wrapper_stdout: stdout_output_wrapper ? stdout_output_wrapper.getContent() : undefined,\r\n                output_wrapper_stderr: stderr_output_wrapper ? stderr_output_wrapper.getContent() : undefined,\r\n            },\r\n            this,\r\n            sc_event,\r\n            [\r\n                this.getNonPreactionsDependentVariables(), // First set: All variables that are not tied to any preactions.\r\n                this.getPreactionsDependentVariables(), // Second set: Variables that are tied to preactions. Can be an empty set.\r\n            ],\r\n            [\r\n                // Do not escape variables in stdin, because shells won't interpret special characters in stdin. All characters are considered literal.\r\n                \"stdinContent\",\r\n                // Do not escape variables in output wrappers, because they are not going through a shell and escape characters would be visible in the end result.\r\n                'output_wrapper_stdout',\r\n                'output_wrapper_stderr',\r\n            ],\r\n        );\r\n    }\r\n\r\n    public setObsidianCommand(obsidian_command: Command) {\r\n        this.obsidian_command = obsidian_command;\r\n    }\r\n\r\n    public getObsidianCommand() {\r\n        return this.obsidian_command;\r\n    }\r\n\r\n    /**\r\n     * No renaming is done if the shell command is excluded from the command palette.\r\n     */\r\n    public renameObsidianCommand(shell_command: string, alias: string) {\r\n        // Rename the command in command palette\r\n        const prefix = this.plugin.getPluginName() + \": \"; // Normally Obsidian prefixes all commands with the plugin name automatically, but now that we are actually _editing_ a command in the palette (not creating a new one), Obsidian won't do the prefixing for us.\r\n\r\n        // Check that the shell command is actually registered to Obsidian's command palette.\r\n        if (undefined !== this.obsidian_command) {\r\n            // Yes, the shell command is registered in Obsidian's command palette.\r\n            // Update the command palette name.\r\n            this.obsidian_command.name = prefix + generateObsidianCommandName(this.plugin, shell_command, alias);\r\n        }\r\n        // If the shell command's \"command_palette_availability\" settings is set to \"disabled\", then the shell command is not present in this.obsidian_command and so the command palette name does not need updating.\r\n    }\r\n\r\n    /**\r\n     * Clears an internal cache used by .getPreactions().\r\n     * Only needed to be called after creating new PreactionConfigurations or deleting old ones. Should not need to be called\r\n     * when modifying properties in existing PreactionConfigurations.\r\n     */\r\n    public resetPreactions() {\r\n        debugLog(`TShellCommand ${this.getId()}: Resetting preactions.`);\r\n        delete this.cached_preactions;\r\n    }\r\n\r\n    private cached_preactions: Preaction[] | undefined;\r\n    public getPreactions(): Preaction[] {\r\n        debugLog(`TShellCommand ${this.getId()}: Getting preactions.`);\r\n        if (!this.cached_preactions) {\r\n            this.cached_preactions = [];\r\n            let preaction_configuration: PreactionConfiguration;\r\n            for (preaction_configuration of this.getConfiguration().preactions) {\r\n                // Only create the preaction if it's enabled.\r\n                if (preaction_configuration.enabled) {\r\n                    // Yes, it's enabled.\r\n                    // Instantiate the Preaction.\r\n                    this.cached_preactions.push(createPreaction(this.plugin, preaction_configuration, this));\r\n                }\r\n            }\r\n        }\r\n        return this.cached_preactions;\r\n    }\r\n\r\n    /**\r\n     * Returns Variables that are not dependent on any Preaction.\r\n     * @private Can be made public if needed.\r\n     */\r\n    private getNonPreactionsDependentVariables(): VariableSet {\r\n        debugLog(`TShellCommand ${this.getId()}: Getting non preactions dependent variables.`);\r\n        const all_variables = this.plugin.getVariables();\r\n        return removeFromSet(all_variables, this.getPreactionsDependentVariables());\r\n    }\r\n\r\n    /**\r\n     * @private Can be made public if needed.\r\n     */\r\n    private getPreactionsDependentVariables(): VariableSet {\r\n        debugLog(`TShellCommand ${this.getId()}: Getting preactions dependent variables.`);\r\n        let dependent_variables = new VariableSet();\r\n        for (const preaction of this.getPreactions()) {\r\n            dependent_variables = mergeSets(dependent_variables, preaction.getDependentVariables());\r\n        }\r\n        return dependent_variables;\r\n    }\r\n\r\n    /**\r\n     * @return Returns undefined, if no configuration is defined for this variable.\r\n     * @param variable\r\n     * @param canInherit If true, can get default value configuration from Variable configuration (= upper level configuration in this case). Can be set to false in situations where it's important to know what the shell command itself has defined or not defined.\r\n     */\r\n    public getDefaultValueConfigurationForVariable(variable: Variable, canInherit = true): InheritableVariableDefaultValueConfiguration | null {\r\n        const defaultValueConfiguration: InheritableVariableDefaultValueConfiguration | undefined = this.configuration.variable_default_values[variable.getIdentifier()];\r\n        if (undefined === defaultValueConfiguration || defaultValueConfiguration.type === \"inherit\") {\r\n            // This shell command does not specify a default value.\r\n            if (canInherit) {\r\n                // Return a global configuration (but even that can be undefined).\r\n                return variable.getGlobalDefaultValueConfiguration(); // Can return undefined.\r\n            }\r\n            // If inheriting is denied, pass to return the defaultValueConfiguration that were gotten from this.configuration.variable_default_values.\r\n        }\r\n        return defaultValueConfiguration;\r\n    }\r\n\r\n    /**\r\n     * Returns an URI that can be used in links (in or outside of Obsidian) to execute this shell command. The URI also\r\n     * contains stubs for any possible CustomVariables that might be used in the shell command (if any).\r\n     */\r\n    public getExecutionURI() {\r\n        const execution_uri = this.plugin.getObsidianURI(SC_Plugin.SHELL_COMMANDS_URI_ACTION, {execute: this.getId()});\r\n\r\n        // Get a list CustomVariables that the shell command uses.\r\n        const custom_variables = new VariableSet();\r\n        for (const custom_variable of getUsedVariables(this.plugin, this.getShellCommand())) {\r\n            // Check that the variable IS a CustomVariable.\r\n            if (custom_variable instanceof CustomVariable) {\r\n                custom_variables.add(custom_variable);\r\n            }\r\n        }\r\n\r\n        // Exclude variables whose values will come from Preactions - they will not probably be needed in the URI.\r\n        const custom_variables_suitable_for_uri = removeFromSet(custom_variables, this.getPreactionsDependentVariables());\r\n\r\n        // Append the suitable custom variable names to the uri.\r\n        let execution_uri_with_variables = execution_uri;\r\n        for (const custom_variable of custom_variables_suitable_for_uri) {\r\n            execution_uri_with_variables += \"&\" + custom_variable.variable_name + \"=\";\r\n        }\r\n\r\n        // Finished.\r\n        return execution_uri_with_variables;\r\n    }\r\n\r\n    /**\r\n     * Returns an adjacent TShellCommand that appears next in the configuration list. Returns undefined, if this is the\r\n     * last TShellCommand. Used in settings to switch quickly from one TShellCommand to another.\r\n     */\r\n    public nextTShellCommand() {\r\n        const t_shell_commands = Object.values(this.plugin.getTShellCommands());\r\n        const this_index = t_shell_commands.indexOf(this);\r\n        if (this_index === t_shell_commands.length - 1) {\r\n            return undefined;\r\n        }\r\n        return t_shell_commands[this_index + 1];\r\n    }\r\n\r\n    /**\r\n     * Returns an adjacent TShellCommand that appears before in the configuration list. Returns undefined, if this is the\r\n     * first TShellCommand. Used in settings to switch quickly from one TShellCommand to another.\r\n     */\r\n    public previousTShellCommand() {\r\n        const t_shell_commands = Object.values(this.plugin.getTShellCommands());\r\n        const this_index = t_shell_commands.indexOf(this);\r\n        if (this_index === 0) {\r\n            return undefined;\r\n        }\r\n        return t_shell_commands[this_index - 1];\r\n    }\r\n}\r\n\r\n/**\r\n * TODO: The name ShellCommandParsingResult sounds like this would be a sub-interface of ParsingResult, although the interfaces are very different. Rename this to something better. Candidate names:\r\n *  - ParsedShellCommandProperties\r\n *  - ParsedShellCommandStrings\r\n */\r\nexport interface ShellCommandParsingResult {\r\n    shell_command: string,\r\n    alias: string,\r\n    environment_variable_path_augmentation: string,\r\n    stdinContent?: string,\r\n    output_wrapper_stdout?: string,\r\n    output_wrapper_stderr?: string,\r\n    succeeded: boolean;\r\n    error_messages: string[];\r\n}\r\n\r\nexport type ShellCommandParsingProcess = ParsingProcess<shell_command_parsing_map>;\r\n\r\ntype shell_command_parsing_map = {\r\n    shell_command: string,\r\n    alias: string,\r\n    environment_variable_path_augmentation: string,\r\n    stdinContent?: string,\r\n    output_wrapper_stdout?: string,\r\n    output_wrapper_stderr?: string,\r\n};","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../../main\";\r\nimport {\r\n    GlobalVariableDefaultValueConfiguration,\r\n    InheritableVariableDefaultValueConfiguration,\r\n    Variable,\r\n    VariableDefaultValueType,\r\n    VariableDefaultValueTypeWithInherit,\r\n} from \"../../variables/Variable\";\r\nimport {\r\n    Setting,\r\n    TextAreaComponent,\r\n} from \"obsidian\";\r\nimport {createAutocomplete} from \"./Autocomplete\";\r\nimport {TShellCommand} from \"../../TShellCommand\";\r\nimport {CustomVariable} from \"../../variables/CustomVariable\";\r\nimport {gotoURL} from \"../../Common\";\r\n\r\nexport function createVariableDefaultValueFields(plugin: SC_Plugin, containerElement: HTMLElement, targetObject: Variable | TShellCommand) {\r\n\r\n    // Add default value fields for each variable that can have a default value.\r\n    for (const variable of plugin.getVariables()) {\r\n\r\n        // Only add fields for variables that are not always accessible.\r\n        if (!variable.isAlwaysAvailable()) {\r\n            const setting = createVariableDefaultValueField(\r\n                plugin,\r\n                containerElement,\r\n                variable.getFullName(),\r\n                variable,\r\n                targetObject\r\n            );\r\n\r\n            // Documentation link\r\n            if (!(variable instanceof CustomVariable)) {\r\n                setting.addExtraButton(extraButton => extraButton\r\n                    .setIcon(\"help\")\r\n                    .setTooltip(\"Documentation: \" + variable.getFullName() + \" variable\")\r\n                    .onClick(() => gotoURL(variable.getDocumentationLink())),\r\n                );\r\n            }\r\n        }\r\n    }\r\n\r\n}\r\n\r\n/**\r\n *\r\n * @param plugin\r\n * @param containerElement\r\n * @param settingName\r\n * @param variable The variable whose default value will be configured by the created setting field.\r\n * @param targetObject In which object's configuration the default value settings should be stored. Can be a TShellCommand or a Variable (either CustomVariable or a built-in one).\r\n */\r\nexport function createVariableDefaultValueField(\r\n        plugin: SC_Plugin,\r\n        containerElement: HTMLElement,\r\n        settingName: string,\r\n        variable: Variable,\r\n        targetObject?: Variable | TShellCommand,\r\n    ): Setting {\r\n\r\n    if (undefined === targetObject) {\r\n        // No configuration target is defined, so use the variable as a target.\r\n        targetObject = variable;\r\n    }\r\n\r\n    const targetType =\r\n        targetObject instanceof TShellCommand\r\n            ? 'tShellCommand'\r\n            : targetObject instanceof CustomVariable\r\n                ? 'customVariable'\r\n                : 'builtinVariable'\r\n    ;\r\n\r\n    if (\"customVariable\" === targetType || \"builtinVariable\" === targetType) {\r\n        if (targetObject !== variable) {\r\n            throw new Error(\"If defining 'targetObject' argument as a Variable, it should be the same as the 'variable' argument.\");\r\n        }\r\n    }\r\n\r\n    // Get an identifier for a variable (an id, if it's a CustomVariable, otherwise the variable's name).\r\n    const variableIdentifier = variable.getIdentifier();\r\n\r\n    // If a default value has been defined for this variable (and this targetObject), retrieve the configuration.\r\n    let defaultValueConfiguration: GlobalVariableDefaultValueConfiguration | InheritableVariableDefaultValueConfiguration | null;\r\n    switch (targetType) {\r\n        case \"tShellCommand\":\r\n            defaultValueConfiguration = (targetObject as TShellCommand).getDefaultValueConfigurationForVariable(variable, false);\r\n            break;\r\n        case \"builtinVariable\": // Both classes have...\r\n        case \"customVariable\":  // ... the getGlobalDefaultValueConfiguration() method.\r\n            defaultValueConfiguration = (targetObject as Variable | CustomVariable).getGlobalDefaultValueConfiguration();\r\n            break;\r\n    }\r\n\r\n    // A function for creating configuration in onChange() callbacks if the variable does not yet have one for this configuration.\r\n    const createDefaultValueConfiguration = () => {\r\n        const configuration: GlobalVariableDefaultValueConfiguration /* This type should be compatible also when assigning the configuration to a TShellCommand, which actually uses InheritableVariableDefaultValueConfiguration instead of Global*. */ = {\r\n            type: \"show-errors\",\r\n            value: \"\",\r\n        };\r\n\r\n        // Store the configuration to the target object's configuration.\r\n        switch (targetType) {\r\n            case \"tShellCommand\":\r\n                (targetObject as TShellCommand).getConfiguration().variable_default_values[variableIdentifier] = configuration;\r\n                break;\r\n            case \"builtinVariable\":\r\n                if (undefined === plugin.settings.builtin_variables[variableIdentifier]) {\r\n                    // Create a config object for this variable if it does not exist yet.\r\n                    plugin.settings.builtin_variables[variableIdentifier] = {default_value: null};\r\n                }\r\n                plugin.settings.builtin_variables[variableIdentifier].default_value = configuration;\r\n                break;\r\n            case \"customVariable\":\r\n                (targetObject as CustomVariable).getConfiguration().default_value = configuration;\r\n                break;\r\n        }\r\n        return configuration;\r\n    };\r\n\r\n    let textareaComponent: TextAreaComponent;\r\n\r\n    // A function for updating textareaComponent visibility.\r\n    const updateTextareaComponentVisibility = (type: string) => {\r\n        if (\"value\" === type) {\r\n            textareaComponent.inputEl.removeClass(\"SC-hide\");\r\n        } else {\r\n            textareaComponent.inputEl.addClass(\"SC-hide\");\r\n        }\r\n    };\r\n\r\n    // Define a set of options for default value type\r\n    const defaultValueTypeOptions = {\r\n        \"inherit\": \"\", // Will be updated or deleted below.\r\n        \"show-errors\": \"Cancel execution and show errors\",\r\n        \"cancel-silently\": \"Cancel execution silently\",\r\n        \"value\": \"Execute with value:\",\r\n    };\r\n    switch (targetType) {\r\n        case \"tShellCommand\": {\r\n            // Shell commands can have the \"inherit\" type.\r\n            const globalDefaultValueConfiguration: GlobalVariableDefaultValueConfiguration | null = variable.getGlobalDefaultValueConfiguration();\r\n            const globalDefaultValueType: VariableDefaultValueType = globalDefaultValueConfiguration ? globalDefaultValueConfiguration.type : \"show-errors\";\r\n            defaultValueTypeOptions.inherit = \"Inherit: \" + defaultValueTypeOptions[globalDefaultValueType];\r\n            if (\"value\" === globalDefaultValueType) {\r\n                defaultValueTypeOptions.inherit += \" \" + globalDefaultValueConfiguration?.value;\r\n            }\r\n            break;\r\n        }\r\n        case \"builtinVariable\":\r\n        case \"customVariable\": {\r\n            // Variables do not have the \"inherit\" type.\r\n            // @ts-ignore Don't yell about removing a non-optional property \"inherit\".\r\n            delete defaultValueTypeOptions.inherit;\r\n        }\r\n    }\r\n\r\n    // Create the default value setting\r\n    const defaultValueSetting: Setting = new Setting(containerElement)\r\n        .setName(settingName)\r\n        .setDesc(\"If not available, then:\")\r\n        .setTooltip(variable.getAvailabilityTextPlain())\r\n        .addDropdown(dropdown => dropdown\r\n            .addOptions(defaultValueTypeOptions)\r\n            .setValue(\r\n                defaultValueConfiguration\r\n                ? defaultValueConfiguration.type\r\n                : \"tShellCommand\" === targetType\r\n                    ? \"inherit\"     // If configuring a TShellCommand, then default config type should be \"inherit\".\r\n                    : \"show-errors\" // If configuring a Variable, then default config type should be \"show-errors\", because \"inherit\" is not available.\r\n            )\r\n            .onChange(async (newType: VariableDefaultValueTypeWithInherit) => {\r\n                if (!defaultValueConfiguration) {\r\n                    defaultValueConfiguration = createDefaultValueConfiguration();\r\n                }\r\n\r\n                // Set the new type\r\n                defaultValueConfiguration.type = newType;\r\n                if (targetType === \"tShellCommand\") {\r\n                    // Shell commands:\r\n                    if (\"inherit\" === newType && defaultValueConfiguration.value === \"\") {\r\n                        // If \"inherit\" is selected and no text value is typed, the configuration file can be cleaned up by removing this configuration object completely.\r\n                        // Prevent deleting, if a text value is present, because the user might want to keep it if they will later change 'type' to 'value'.\r\n                        delete (targetObject as TShellCommand).getConfiguration().variable_default_values[variableIdentifier];\r\n                    }\r\n                } else {\r\n                    // Variables:\r\n                    if (\"show-errors\" === newType && defaultValueConfiguration.value === \"\") {\r\n                        // If \"show-errors\" is selected and no text value is typed, the configuration file can be cleaned up by removing this configuration object completely.\r\n                        // Prevent deleting, if a text value is present, because the user might want to keep it if they will later change 'type' to 'value'.\r\n                        switch (targetType) {\r\n                            case \"builtinVariable\":\r\n                                plugin.settings.builtin_variables[variableIdentifier].default_value = null;\r\n                                break;\r\n                            case \"customVariable\":\r\n                                (targetObject as CustomVariable).getConfiguration().default_value = null;\r\n                                break;\r\n                        }\r\n                    }\r\n                }\r\n\r\n                // Show/hide the textarea\r\n                updateTextareaComponentVisibility(newType);\r\n\r\n                // Save the settings\r\n                await plugin.saveSettings();\r\n            }),\r\n        )\r\n        .addTextArea(textarea => textareaComponent = textarea\r\n            .setValue(defaultValueConfiguration ? defaultValueConfiguration.value : \"\")\r\n            .onChange(async (newValue: string) => {\r\n                if (!defaultValueConfiguration) {\r\n                    defaultValueConfiguration = createDefaultValueConfiguration();\r\n                }\r\n\r\n                // Set the new text value\r\n                defaultValueConfiguration.value = newValue;\r\n\r\n                // Save the settings\r\n                await plugin.saveSettings();\r\n            }).then((textareaComponent) => {\r\n                // Autocomplete for the textarea.\r\n                if (plugin.settings.show_autocomplete_menu) {\r\n                    createAutocomplete(plugin, textareaComponent.inputEl, () => textareaComponent.onChanged());\r\n                }\r\n            }),\r\n        )\r\n    ;\r\n    updateTextareaComponentVisibility(\r\n        defaultValueConfiguration\r\n            ? defaultValueConfiguration.type\r\n            : targetType === \"tShellCommand\"\r\n                ? \"show-errors\" // It does not really matter if passing \"show-errors\" ....\r\n                : \"inherit\",    // ... or \"inherit\", both will have the same effect (= hide a textarea), but this is more future-proof.\r\n    );\r\n\r\n    return defaultValueSetting;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Setting} from \"obsidian\";\r\nimport {SC_MainSettings} from \"../../settings/SC_MainSettings\";\r\nimport {CustomVariableInstance} from \"./CustomVariableInstance\";\r\nimport {\r\n    getIDGenerator,\r\n    Model,\r\n    ParentModelOneToManyIdRelation,\r\n} from \"../../imports\";\r\nimport {debugLog} from \"../../Debug\";\r\nimport {\r\n    GlobalVariableDefaultValueConfiguration,\r\n} from \"../../variables/Variable\";\r\nimport {createVariableDefaultValueField} from \"../../settings/setting_elements/createVariableDefaultValueFields\";\r\n\r\nexport class CustomVariableModel extends Model {\r\n\r\n    private custom_variable_instances: CustomVariableInstanceMap = new CustomVariableInstanceMap;\r\n\r\n    public getSingularName(): string {\r\n        return \"Custom variable\";\r\n    }\r\n\r\n    protected defineParentConfigurationRelation(custom_variable_instance: CustomVariableInstance): ParentModelOneToManyIdRelation {\r\n        debugLog(`CustomVariableModel: Defining parent configuration relation for CustomVariableInstance ${custom_variable_instance.getID()}.`);\r\n        return {\r\n            type: \"one-to-many-id\",\r\n            key: \"custom_variables\",\r\n            id: custom_variable_instance.getID(),\r\n        };\r\n    }\r\n\r\n    public loadInstances(parent_configuration: SC_MainSettings): CustomVariableInstanceMap {\r\n        debugLog(`CustomVariableModel: Loading CustomVariableInstances.`);\r\n        this.custom_variable_instances.clear();\r\n        parent_configuration.custom_variables.forEach((custom_variable_configuration: CustomVariableConfiguration) => {\r\n            this.custom_variable_instances.set(\r\n                custom_variable_configuration.id,\r\n                new CustomVariableInstance(this, custom_variable_configuration, parent_configuration)\r\n            );\r\n        });\r\n        return this.custom_variable_instances;\r\n    }\r\n\r\n    public newInstance(parent_configuration: SC_MainSettings): CustomVariableInstance {\r\n        debugLog(`CustomVariableModel: Creating a new CustomVariableInstance.`);\r\n\r\n        // Create a default configuration object\r\n        const custom_variable_configuration: CustomVariableConfiguration = this.getDefaultConfiguration();\r\n        parent_configuration.custom_variables.push(custom_variable_configuration);\r\n\r\n        // Create a CustomVariableInstance for handling the configuration\r\n        const custom_variable_instance = new CustomVariableInstance(this, custom_variable_configuration, parent_configuration);\r\n        this.custom_variable_instances.set(custom_variable_configuration.id, custom_variable_instance);\r\n\r\n        // Create an operational variable.\r\n        this.plugin.getVariables().add(custom_variable_instance.createCustomVariable());\r\n\r\n        return custom_variable_instance;\r\n        // TODO: Move this logic to the base Model class.\r\n    }\r\n\r\n    protected _createSettingFields(instance: CustomVariableInstance, container_element: HTMLElement): Setting {\r\n        debugLog(`CustomVariableModel: Creating setting fields for CustomVariableInstance ${instance.getID()}.`);\r\n\r\n        // Make the fields appear closer together.\r\n        container_element.addClass(\"SC-setting-group\");\r\n\r\n        // Heading setting\r\n        const heading_setting = new Setting(container_element)\r\n            .setName(instance.getFullName())\r\n            .setHeading()\r\n        ;\r\n\r\n        // Name setting\r\n        new Setting(container_element)\r\n            .setName(\"Variable name\")\r\n            .setDesc(\"Must contain at least one character. Allowed characters are letters a-z, numbers 0-9 and an underscore _\")\r\n            .setClass(\"SC-custom-variable-name-setting\")\r\n            .addText(text => text\r\n                .setValue(instance.configuration.name)\r\n                .onChange((new_name: string) => {\r\n                    // TODO: Find a way to create this kind of trivial onChange() functions in the Model base class.\r\n                    instance.setIfValid(\"name\", new_name).then(async () => {\r\n                        // Valid\r\n                        heading_setting.setName(instance.getFullName()); // Also removes a possible warning message.\r\n                        instance.getCustomVariable().updateProperties(); // Update the name also to the operational variable, not only in configuration.\r\n                        await this.plugin.saveSettings();\r\n                        await this.plugin.updateCustomVariableViews();\r\n                    }, (reason: string | unknown) => {\r\n                        // Not valid\r\n                        if (typeof reason === \"string\") {\r\n                            // This is a validation error message.\r\n                            // Display a warning message.\r\n                            heading_setting.setName(reason + \" The name was not saved.\");\r\n                        } else {\r\n                            // Some other runtime error has occurred.\r\n                            throw reason;\r\n                        }\r\n                    });\r\n                }),\r\n            )\r\n        ;\r\n\r\n        // Description setting\r\n        new Setting(container_element)\r\n            .setName(\"Description\")\r\n            .setDesc(\"Appears in autocomplete lists along with the variable name, and also in the 'Custom variables' pane, if you use it.\")\r\n            .addText(text => text\r\n                .setValue(instance.configuration.description)\r\n                .onChange(async (new_description: string) => {\r\n                    // TODO: Find a way to create this kind of trivial onChange() functions in the Model base class.\r\n                    instance.configuration.description = new_description;\r\n                    instance.getCustomVariable().updateProperties(); // Update the description also to the operational variable, not only in configuration.\r\n                    await this.plugin.saveSettings();\r\n                    await this.plugin.updateCustomVariableViews();\r\n                }),\r\n            )\r\n        ;\r\n\r\n        // Default value setting\r\n        createVariableDefaultValueField(\r\n            this.plugin,\r\n            container_element,\r\n            \"Default value\",\r\n            instance.getCustomVariable(),\r\n        );\r\n\r\n        return heading_setting;\r\n    }\r\n\r\n    public validateValue(custom_variable_instance: CustomVariableInstance, field: keyof CustomVariableInstance[\"configuration\"], custom_variable_name: string): Promise<void> {\r\n        debugLog(`CustomVariableModel: Validating ${field} value ${custom_variable_name} for CustomVariableInstance ${custom_variable_instance.getID()}.`);\r\n        return new Promise<void>((resolve, reject) => {\r\n            switch (field) {\r\n                case \"name\":\r\n                    // Check that the name contains only characters a-z, 0-9 and/or underline _\r\n                    if (!custom_variable_name.match(/^[\\w\\d]+$/u)) {\r\n                        // Incorrect format.\r\n                        reject(`The name {{_${custom_variable_name}}} does not meet the naming requirements.`);\r\n                        return;\r\n                    }\r\n\r\n                    // Check if the name is a duplicate.\r\n                    if (this.isCustomVariableNameDuplicate(custom_variable_name, custom_variable_instance)) {\r\n                        // It's a duplicate.\r\n                        reject(`The name {{_${custom_variable_name}}} is already reserved.`);\r\n                    } else {\r\n                        // It's unique.\r\n                        resolve();\r\n                    }\r\n                    return;\r\n                default:\r\n                    // Other fields do not need validation.\r\n                    resolve();\r\n                    return;\r\n            }\r\n        });\r\n    }\r\n\r\n    public getDefaultConfiguration(): CustomVariableConfiguration {\r\n        // Generate a unique name for the variable by using a sequential number.\r\n        let sequential_number = 1;\r\n        while (this.isCustomVariableNameDuplicate(String(sequential_number))) {\r\n            sequential_number++;\r\n        }\r\n\r\n        // Create a configuration object.\r\n        return {\r\n            id: getIDGenerator().generateID(),\r\n            name: String(sequential_number),\r\n            description: \"\",\r\n            default_value: null,\r\n        };\r\n    }\r\n\r\n    protected async _deleteInstance(custom_variable_instance: CustomVariableInstance): Promise<void> {\r\n        debugLog(`CustomVariableModel: Deleting CustomVariableInstance ${custom_variable_instance.getID()}.`);\r\n\r\n        // Remove the CustomVariableInstance from all PromptFields that use it.\r\n        for (const prompt of this.plugin.getPrompts().values()) {\r\n            for (const prompt_field of prompt.prompt_fields) {\r\n                if (custom_variable_instance.getID() === prompt_field.configuration.target_variable_id) {\r\n                    // This prompt field uses this CustomVariableInstance.\r\n                    // Remove the variable from use.\r\n                    prompt_field.configuration.target_variable_id = \"\";\r\n                    // Saving is done later, after the _deleteInstance() call.\r\n                }\r\n            }\r\n        }\r\n\r\n        // Delete CustomVariable\r\n        try {\r\n            this.plugin.getVariables().delete(custom_variable_instance.getCustomVariable());\r\n        } catch (error) {\r\n            // If custom_variable_instance.getCustomVariable() failed, no need to do anything. It just means there is no CustomVariable, so there's nothing to delete.\r\n        }\r\n\r\n        // Delete CustomVariableInstance\r\n        this.custom_variable_instances.delete(custom_variable_instance.getID());\r\n\r\n        // remove the variable from custom variable side panes.\r\n        await this.plugin.updateCustomVariableViews();\r\n    }\r\n\r\n    /**\r\n     * Can be changed to public if needed.\r\n     */\r\n    private isCustomVariableNameDuplicate(custom_variable_name: string, ignore_custom_variable_instance?: CustomVariableInstance): boolean {\r\n        let is_duplicate = false;\r\n        this.custom_variable_instances.forEach((custom_variable2_instance: CustomVariableInstance, custom_variable_id: string) => {\r\n            // First check can the current custom variable attend to the duplicate test.\r\n            if (ignore_custom_variable_instance && custom_variable_id === ignore_custom_variable_instance.getID()) {\r\n                // Don't check this instance. This skipping is used for the current owner of the name.\r\n                return;\r\n            }\r\n\r\n            // Now do the actual duplicate test.\r\n            if (custom_variable_name.toLocaleLowerCase() === custom_variable2_instance.configuration.name.toLocaleLowerCase()) {\r\n                is_duplicate = true;\r\n            }\r\n        });\r\n        return is_duplicate;\r\n    }\r\n}\r\n\r\nexport interface CustomVariableConfiguration {\r\n    id: string,\r\n    name: string,\r\n    description: string,\r\n    default_value: GlobalVariableDefaultValueConfiguration | null,\r\n}\r\n\r\nexport class CustomVariableInstanceMap extends Map<string, CustomVariableInstance> {}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Modal} from \"../../SC_Modal\";\r\nimport SC_Plugin from \"../../main\";\r\nimport {\r\n    CustomVariableInstance,\r\n    CustomVariableModel,\r\n    getModel,\r\n} from \"../../imports\";\r\nimport {Setting} from \"obsidian\";\r\n\r\nexport class CustomVariableSettingsModal extends SC_Modal {\r\n\r\n    private created = false;\r\n\r\n    constructor(\r\n        plugin: SC_Plugin,\r\n        private readonly custom_variable_instance: CustomVariableInstance,\r\n        private readonly on_after_creation: () => void,\r\n        private readonly on_after_cancelling: () => void,\r\n    ) {\r\n        super(plugin);\r\n    }\r\n\r\n    public onOpen(): void {\r\n        super.onOpen();\r\n\r\n        const model = getModel<CustomVariableModel>(CustomVariableModel.name);\r\n        model.createSettingFields(this.custom_variable_instance, this.modalEl, false);\r\n\r\n        new Setting(this.modalEl)\r\n            .addButton(button => button\r\n                .setButtonText(\"Create\")\r\n                .onClick(() => this.approve()),\r\n            )\r\n        ;\r\n    }\r\n\r\n    protected approve(): void {\r\n        this.created = true;\r\n        this.on_after_creation();\r\n        this.close();\r\n    }\r\n\r\n    public onClose(): void {\r\n        super.onClose();\r\n\r\n        if (!this.created) {\r\n            this.on_after_cancelling();\r\n        }\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    ItemView,\r\n    WorkspaceLeaf,\r\n} from \"obsidian\";\r\nimport SC_Plugin from \"../../main\";\r\n\r\nexport class CustomVariableView extends ItemView {\r\n\r\n    public static ViewType = \"SC-custom-variables-view\";\r\n\r\n    constructor(\r\n        private plugin: SC_Plugin,\r\n        leaf: WorkspaceLeaf\r\n    ) {\r\n        super(leaf);\r\n    }\r\n\r\n    public getDisplayText(): string {\r\n        return \"Custom variables\";\r\n    }\r\n\r\n    public getViewType(): string {\r\n        return CustomVariableView.ViewType;\r\n    }\r\n\r\n    public getIcon() {\r\n        return \"code-glyph\";\r\n    }\r\n\r\n    private container_element: HTMLDivElement;\r\n    protected async onOpen(): Promise<void> {\r\n        this.container_element = this.containerEl.children[1].createDiv(); // I don't know why I cannot create elements directly under this.containerEl (they wouldn't show up). I did the same thing as was done here: https://marcus.se.net/obsidian-plugin-docs/guides/custom-views (referenced 2022-03-23).\r\n        this.container_element.addClass(\"container\");\r\n\r\n        await this.updateContent();\r\n    }\r\n\r\n    public async updateContent() {\r\n        this.container_element.empty();\r\n        this.container_element.createEl(\"h3\", {text: \"Custom variables\"});\r\n        const variableListElement: HTMLUListElement = this.container_element.createEl(\"ul\");\r\n        for (const customVariableInstance of this.plugin.getCustomVariableInstances().values()) {\r\n            let customVariableValue: string | null = (await customVariableInstance.getCustomVariable().getValue()).value;\r\n            let customVariableState: string | null = null;\r\n            if (null === customVariableValue) {\r\n                // The variable has no value yet.\r\n                if (\"value\" === customVariableInstance.configuration.default_value?.type) {\r\n                    // Indicate that the variable has a default value defined, which will practically be used as long as no overriding value is set.\r\n                    if (\"\" === customVariableInstance.configuration.default_value.value.trim()) {\r\n                        customVariableState = \"No value yet, but defaults to: An empty text.\";\r\n                    } else {\r\n                        customVariableState = \"No value yet, but defaults to: \"; // The value will appear next to the state text later below.\r\n                        customVariableValue = customVariableInstance.configuration.default_value.value;\r\n                    }\r\n                } else {\r\n                    // No default value is defined, so no value is accessible.\r\n                    customVariableState = \"No value yet.\";\r\n                }\r\n            } else if (\"\" === customVariableValue) {\r\n                customVariableState = \"An empty text.\";\r\n            }\r\n            const variableListItemElement = variableListElement.createEl(\"li\", {\r\n                text: customVariableInstance.getFullName(),\r\n                attr: {\r\n                    \"aria-label\": customVariableInstance.configuration.description,\r\n                    \"class\": \"SC-custom-variable-view-list-item\",\r\n                },\r\n            });\r\n            variableListItemElement.createEl(\"br\");\r\n            if (null !== customVariableState) {\r\n                variableListItemElement.createEl(\"em\").insertAdjacentText(\"beforeend\", customVariableState);\r\n            }\r\n            if (null !== customVariableValue) {\r\n                // Bold normal values to make them more prominent in contrast to variable names and \"No value yet.\"/\"An empty text.\" texts.\r\n                variableListItemElement.createEl(\"strong\").insertAdjacentText(\"beforeend\", customVariableValue);\r\n            }\r\n        }\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../main\";\r\nimport {ShellCommandParsingProcess, TShellCommand} from \"../TShellCommand\";\r\nimport {SC_Event} from \"../events/SC_Event\";\r\nimport {VariableSet} from \"../variables/loadVariables\";\r\nimport {\r\n    Preaction_Prompt,\r\n    Preaction_Prompt_Configuration,\r\n} from \"../imports\";\r\n\r\nexport abstract class Preaction {\r\n\r\n    protected constructor(\r\n        protected readonly plugin: SC_Plugin,\r\n        public readonly configuration: PreactionConfiguration,\r\n        protected readonly t_shell_command: TShellCommand,\r\n    ) {}\r\n\r\n    /**\r\n     * Returns a boolean indicating whether the pipeline of preactions can proceed to the next preaction. False indicates\r\n     * to cancel running any possible later preactions, and also cancels execution of the shell command. If all preactions'\r\n     * promises return true, the shell command will be executed.\r\n     * @protected\r\n     */\r\n    protected abstract doPreaction(parsing_process: ShellCommandParsingProcess, sc_event: SC_Event | null): Promise<boolean>;\r\n\r\n    /**\r\n     * Maybe this wrapper method is unneeded, but have it for a while at least.\r\n     */\r\n    public perform(parsing_process: ShellCommandParsingProcess, sc_event: SC_Event | null): Promise<boolean> {\r\n        return this.doPreaction(parsing_process, sc_event);\r\n    }\r\n\r\n    protected abstract getDefaultConfiguration(): PreactionConfiguration; // TODO: Remove if this won't be used.\r\n\r\n    /**\r\n     * Returns variables that are dependent of this Preaction, i.e. variables whose value is set by this Preaction.\r\n     * If a variable is READ by a Preaction, it is NOT considered to be _dependent_ of the Preaction, as long as the variable's\r\n     * value is not changed by the Preaction.\r\n     *\r\n     * By default, it returns an empty VariableSet, because not all Preactions will use variables at all.\r\n     */\r\n    public getDependentVariables(): VariableSet {\r\n        return new VariableSet();\r\n    }\r\n}\r\n\r\nexport function createPreaction(plugin: SC_Plugin, preaction_configuration: PreactionConfiguration, t_shell_command: TShellCommand): Preaction {\r\n    switch (preaction_configuration.type) {\r\n        case \"prompt\":\r\n            return new Preaction_Prompt(plugin, (preaction_configuration as Preaction_Prompt_Configuration), t_shell_command);\r\n    }\r\n}\r\n\r\nexport interface PreactionConfiguration {\r\n    type: \"prompt\";\r\n    enabled: boolean;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Event} from \"../events/SC_Event\";\r\nimport {VariableSet} from \"../variables/loadVariables\";\r\nimport {\r\n    Preaction,\r\n    PreactionConfiguration,\r\n    Prompt,\r\n} from \"../imports\";\r\nimport SC_Plugin from \"../main\";\r\nimport {ShellCommandParsingProcess, TShellCommand} from \"../TShellCommand\";\r\n\r\nexport class Preaction_Prompt extends Preaction {\r\n\r\n    constructor(\r\n        plugin: SC_Plugin,\r\n        public readonly configuration: Preaction_Prompt_Configuration,\r\n        t_shell_command: TShellCommand,\r\n    ) {\r\n        super(plugin, configuration, t_shell_command);\r\n    }\r\n\r\n    protected doPreaction(parsing_process: ShellCommandParsingProcess, sc_event: SC_Event): Promise<boolean> {\r\n        // TODO: Now that doPreaction() returns a similar Promise as is received from openPrompt(), consider just returning the same Promise instead of creating a new one.\r\n        return new Promise<boolean>((resolve) => {\r\n            this.getPrompt().openPrompt(this.t_shell_command, parsing_process, sc_event).then((execution_confirmed: boolean) => {\r\n                // The PromptModal has been closed.\r\n                // Check if user wanted to execute the shell command or cancel.\r\n                if (execution_confirmed) {\r\n                    // User wants to execute.\r\n                    resolve(true);\r\n                } else {\r\n                    // User wants to cancel.\r\n                    resolve(false);\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Returns all the CustomVariables whose values this Preaction's Prompt sets.\r\n     */\r\n    public getDependentVariables(): VariableSet {\r\n        const variables = new VariableSet();\r\n        for (const prompt_field of this.getPrompt().prompt_fields) {\r\n            // Check that the PromptField has a target variable defined. Otherwise getTargetVariable() would cause a crash.\r\n            if (\"\" !== prompt_field.configuration.target_variable_id) {\r\n                variables.add(prompt_field.getTargetVariable());\r\n            }\r\n        }\r\n        return variables;\r\n    }\r\n\r\n    /**\r\n     * TODO: Remove.\r\n     */\r\n    protected getDefaultConfiguration(): Preaction_Prompt_Configuration {\r\n        return {\r\n            type: \"prompt\",\r\n            enabled: false,\r\n            prompt_id: \"\",\r\n        };\r\n    }\r\n\r\n    private getPrompt(): Prompt {\r\n        const promptId: string | undefined = this.configuration.prompt_id;\r\n        if (undefined === promptId) {\r\n            throw new Error(\"Prompt id is undefined in configuration.\");\r\n        }\r\n        const prompt: Prompt | undefined = this.plugin.getPrompts().get(promptId);\r\n        if (undefined === prompt) {\r\n            throw new Error(\"Prompt with id '\" + promptId + \"' does not exist\");\r\n        }\r\n        return prompt;\r\n    }\r\n}\r\n\r\nexport function getDefaultPreaction_Prompt_Configuration(): Preaction_Prompt_Configuration {\r\n    return {\r\n        type: \"prompt\",\r\n        enabled: false,\r\n        prompt_id: \"\",\r\n    };\r\n}\r\n\r\nexport interface Preaction_Prompt_Configuration extends PreactionConfiguration {\r\n    type: \"prompt\";\r\n    prompt_id: string | undefined;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {Setting} from \"obsidian\";\r\nimport {SC_Event} from \"../../../events/SC_Event\";\r\nimport {parseVariables} from \"../../../variables/parseVariables\";\r\nimport {TShellCommand} from \"../../../TShellCommand\";\r\nimport {\r\n    CustomVariable,\r\n    CustomVariableInstance,\r\n    Instance,\r\n    Prompt,\r\n    PromptConfiguration,\r\n    PromptFieldModel,\r\n} from \"../../../imports\";\r\n\r\nexport abstract class PromptField extends Instance {\r\n\r\n    /**\r\n     * Contains a value preview element.\r\n     * @protected\r\n     */\r\n    protected preview_setting: Setting;\r\n\r\n    private parsed_value: string | null;\r\n    private parsing_errors: string[] = [];\r\n\r\n    constructor(\r\n        public model: PromptFieldModel,\r\n        public prompt: Prompt,\r\n        public configuration: PromptFieldConfiguration,\r\n        public prompt_field_index: keyof PromptConfiguration[\"fields\"], // TODO: 'keyof' is kind of incorrect here, 'keyof' is for objects, but 'SC_MainSettings[\"custom_variables\"]' is an array with numeric indexes.\r\n    ) {\r\n        super(model, configuration, prompt.configuration);\r\n    }\r\n\r\n    /**\r\n     *\r\n     * @param container_element\r\n     * @param t_shell_command\r\n     * @param sc_event Used when parsing variables for default_value and the inputted value. Needed so that also {{event_*}} variables can be used in prompts.\r\n     */\r\n    public async createField(container_element: HTMLElement, t_shell_command: TShellCommand | null, sc_event: SC_Event | null): Promise<void> {\r\n        await this._createField(container_element, t_shell_command, sc_event);\r\n\r\n        // Create a preview setting element. It will not contain any actual setting elements, just text.\r\n        this.preview_setting = new Setting(container_element);\r\n\r\n        // Parse variables in the default value and insert it to the field.\r\n        // Note that this is a different \"default value\" than what TShellCommand considers as variables' default values! This is about a _field's_ default value, not a variable's default value. t_shell_command is passed in order to allow any possible variables in the field's default value to access the variables' default values (which come from TShellCommand).\r\n        await this.applyDefaultValue(t_shell_command, sc_event);\r\n    }\r\n\r\n    protected abstract _createField(container_element: HTMLElement, t_shell_command: TShellCommand | null, sc_event: SC_Event | null): Promise<void>;\r\n\r\n    public getTitle(): string {\r\n        return this.configuration.label === \"\" ? \"Unlabelled field\" : this.configuration.label;\r\n    }\r\n\r\n    /**\r\n     * Gets a value from the form field.\r\n     * @protected\r\n     */\r\n    protected abstract getValue(): string;\r\n\r\n    /**\r\n     * Sets a value to the form field.\r\n     * @param value\r\n     * @protected\r\n     */\r\n    protected abstract setValue(value: string): void;\r\n\r\n    /**\r\n     * Parses the default value and sets it to the form element.\r\n     * @param t_shell_command\r\n     * @param sc_event\r\n     * @private\r\n     */\r\n    private async applyDefaultValue(t_shell_command: TShellCommand | null, sc_event: SC_Event | null) {\r\n        const default_value = this.configuration.default_value;\r\n        const parsing_result = await parseVariables(this.prompt.model.plugin, default_value, null, t_shell_command, sc_event);\r\n        if (!parsing_result.succeeded) {\r\n            // Parsing failed.\r\n            this.setValue(default_value); // Use the unparsed value. If default value contains a variable that cannot be parsed, a user can see the variable in the prompt modal and either fix it or change it to something else.\r\n        } else {\r\n            // Parsing succeeded.\r\n            this.setValue(parsing_result.parsed_content as string);\r\n        }\r\n        await this.valueHasChanged(t_shell_command, sc_event);\r\n    }\r\n\r\n    public getParsedValue(): string | null {\r\n        return this.parsed_value;\r\n    }\r\n\r\n    /**\r\n     * Tries to get a parsed value, but if it's not available (probably due to incorrect usage of variables), returns an\r\n     * unparsed value instead().\r\n     */\r\n    public getParsedOrRawValue(): string {\r\n        return this.parsed_value ?? this.getValue();\r\n    }\r\n\r\n    public getParsingErrors() {\r\n        return this.parsing_errors;\r\n    }\r\n\r\n    /**\r\n     * Updates this.parsed_value, this.parsing_errors and this.preview_setting .\r\n     *\r\n     * @param t_shell_command\r\n     * @param sc_event\r\n     * @protected\r\n     */\r\n    protected async valueHasChanged(t_shell_command: TShellCommand | null, sc_event: SC_Event | null) {\r\n        let preview: string;\r\n\r\n        // Parse variables in the value.\r\n        const parsing_result = await parseVariables(this.prompt.model.plugin, this.getValue(), null, t_shell_command, sc_event);\r\n        if (!parsing_result.succeeded) {\r\n            // Parsing failed.\r\n            this.parsed_value = null;\r\n            if (parsing_result.error_messages.length > 0) {\r\n                // Display the first error message. If there are more, others can be omitted.\r\n                preview = parsing_result.error_messages[0];\r\n            } else {\r\n                // If there are no error messages, then errors are silently ignored by user's variable configuration, in which case just show the original content.\r\n                preview = parsing_result.original_content;\r\n            }\r\n            this.parsing_errors = parsing_result.error_messages;\r\n        } else {\r\n            // Parsing succeeded\r\n            this.parsed_value = parsing_result.parsed_content;\r\n            preview = parsing_result.parsed_content as string;\r\n            this.parsing_errors = []; // No errors.\r\n        }\r\n\r\n        // Update the preview element.\r\n        if (0 === parsing_result.count_parsed_variables) {\r\n             // If no variables were used, hide the description as it's not needed to repeat the value that already shows up in the form field.\r\n            preview = \"\";\r\n        }\r\n        this.preview_setting.setDesc(preview);\r\n\r\n        // Call a possible external callback\r\n        if (this.on_change_callback) {\r\n            this.on_change_callback();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @param on_change_callback A callback that will be called whenever the field's value is changed.\r\n     */\r\n    public onChange(on_change_callback: () => void) {\r\n        this.on_change_callback = on_change_callback;\r\n    }\r\n    private on_change_callback?: () => void;\r\n\r\n    /**\r\n     * @param on_focus_callback A callback that will be called whenever the field is focused.\r\n     */\r\n    public onFocus(on_focus_callback: (prompt_field: PromptField) => void) {\r\n        this.on_focus_callback = on_focus_callback;\r\n    }\r\n    private on_focus_callback?: (prompt_field: PromptField) => void;\r\n\r\n    /**\r\n     * Should be called by the subclass when the field has gotten focus.\r\n     */\r\n    protected hasGottenFocus() {\r\n        if (this.on_focus_callback) {\r\n            this.on_focus_callback(this);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Forces focus on the field.\r\n     */\r\n    public abstract setFocus(): void;\r\n\r\n    /**\r\n     * Ensures that the field is filled, if it's mandatory. If the field is not mandatory, it's always valid.\r\n     *\r\n     * @return True when valid, false when not valid.\r\n     */\r\n    public validate() {\r\n        if (!this.configuration.required) {\r\n            // No need to validate, because the field is not mandatory.\r\n            return true;\r\n        }\r\n\r\n        // Ensure the field is filled\r\n        return this.isFilled();\r\n    }\r\n\r\n    protected abstract isFilled(): boolean;\r\n\r\n    public getTargetVariableInstance(): CustomVariableInstance {\r\n        const target_variable_id = this.configuration.target_variable_id;\r\n        const custom_variable_instance: CustomVariableInstance | undefined = this.prompt.model.plugin.getCustomVariableInstances().get(target_variable_id);\r\n        if (!custom_variable_instance) {\r\n            throw new Error(this.constructor.name + \".getTargetVariableInstance(): CustomVariableInstance with ID '\" + target_variable_id + \"' was not found\");\r\n        }\r\n        return custom_variable_instance;\r\n    }\r\n\r\n    public getTargetVariable(): CustomVariable {\r\n        const custom_variable_instance = this.getTargetVariableInstance();\r\n        return custom_variable_instance.getCustomVariable();\r\n    }\r\n}\r\n\r\nexport interface PromptFieldConfiguration {\r\n    // type: \"text\"; // TODO: Uncomment when implementing more values than just \"text\". No need to decide the value \"text\" now, it can be changed to \"single-line-text\" or something else, too.\r\n    label: string;\r\n    description: string;\r\n    default_value: string;\r\n    //  TODO: Add 'placeholder'.\r\n    target_variable_id: string;\r\n    required: boolean;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    Setting,\r\n    TextComponent,\r\n} from \"obsidian\";\r\nimport {randomInteger} from \"../../../Common\";\r\nimport {createAutocomplete} from \"../../../settings/setting_elements/Autocomplete\";\r\nimport {\r\n    CustomVariableInstance,\r\n    CustomVariableModel,\r\n    CustomVariableSettingsModal,\r\n    getModel,\r\n    Model,\r\n    ParentModelOneToManyIndexRelation,\r\n    Prompt,\r\n    PromptField,\r\n    PromptField_Text,\r\n    PromptFieldConfiguration,\r\n} from \"../../../imports\";\r\n\r\nexport class PromptFieldModel extends Model {\r\n\r\n    public getSingularName(): string {\r\n        return \"Field\";\r\n    }\r\n\r\n    protected defineParentConfigurationRelation(prompt_field: PromptField): ParentModelOneToManyIndexRelation {\r\n        return {\r\n            type: \"one-to-many-index\",\r\n            key: \"fields\",\r\n            index: prompt_field.prompt_field_index as number,\r\n        };\r\n    }\r\n\r\n    public loadInstances(prompt: Prompt): PromptFieldSet {\r\n        const prompt_fields = new PromptFieldSet;\r\n        prompt.configuration.fields.forEach((field_configuration: PromptFieldConfiguration, index) => {\r\n            prompt_fields.add(\r\n                this.createInstance(prompt, field_configuration, index)\r\n            );\r\n        });\r\n        return prompt_fields;\r\n    }\r\n\r\n    public newInstance(prompt: Prompt): PromptField {\r\n        // TODO: Move this logic to the base Model class.\r\n\r\n        // Setup a default configuration\r\n        const prompt_field_configuration = this.getDefaultConfiguration();\r\n\r\n        // Instantiate a PromptField\r\n        const prompt_field = this.createInstance(prompt, prompt_field_configuration, prompt.configuration.fields.length);\r\n\r\n        // Store the configuration into the prompt's configuration\r\n        prompt.configuration.fields.push(prompt_field_configuration);\r\n\r\n        // Store the PromptField instance into its parent Prompt's list of fields.\r\n        prompt.prompt_fields.add(prompt_field);\r\n\r\n        // Return the PromptField\r\n        return prompt_field;\r\n    }\r\n\r\n    private createInstance(prompt: Prompt, prompt_field_configuration: PromptFieldConfiguration, prompt_field_index: number): PromptField {\r\n        // TODO: When the 'type' field gets implemented on PromptFieldConfiguration, implement some kind of switch structure here to create different types of PromptFields.\r\n        return new PromptField_Text(this, prompt, prompt_field_configuration, prompt_field_index);\r\n    }\r\n\r\n    protected _createSettingFields(prompt_field: PromptField, container_element: HTMLElement): Setting {\r\n        const label_placeholders = [\r\n            \"What is your name?\",\r\n            \"How big is the universe?\",\r\n            \"How long is eternity?\",\r\n            \"What is your lucky number?\",\r\n            \"What is your favorite song?\",\r\n            \"What is your favorite color?\",\r\n            \"How many books have you read?\",\r\n            \"What is the purpose of life?\",\r\n        ];\r\n        const default_value_placeholders = [\r\n            [\"Bond, James Bond\", \"John Doe\", \"Jane Doe\", \"Mr. Bean\"],\r\n            [\"Very big, and still expanding\", \"93 billion light-years\"],\r\n            [\"Infinite\", \"Too long to wait for\"],\r\n            [String(randomInteger(0, 9)), \"I don't have one\"],\r\n            [\"We are the world (USA for Africa)\", \"Heal the world (Michael Jackson)\", \"Imagine (John Lennon)\", \"Circle of life (Elton John)\"],\r\n            [\"Blue as deep as an ocean\", \"Red as love\", \"Grass-green\", \"Snow-white\"],\r\n            [\"Thousands\", \"Many\", \"Countless\", \"None\"],\r\n            [\"Thinking\", \"Being a being\", \"42\"],\r\n        ];\r\n        const label_placeholder_index: number = randomInteger(0, label_placeholders.length - 1);\r\n        const default_value_placeholders_subset: string[] = default_value_placeholders[label_placeholder_index];\r\n\r\n        // Create a list of custom variables\r\n        const custom_variable_options: {[key: string]: string} = {};\r\n        this.plugin.getCustomVariableInstances().forEach((custom_variable_instance: CustomVariableInstance, custom_variable_id: string) => {\r\n            custom_variable_options[custom_variable_id] = custom_variable_instance.getFullName();\r\n        });\r\n\r\n        const on_default_value_setting_change = async (new_default_value: string) => {\r\n            prompt_field.configuration.default_value = new_default_value;\r\n            await this.plugin.saveSettings();\r\n        };\r\n\r\n        // Create the setting fields\r\n        const setting_group_element = container_element.createDiv({attr: {class: \"SC-setting-group\"}});\r\n        let label_setting_component: TextComponent;\r\n        let description_setting_component: TextComponent;\r\n        const setting_group: PromptFieldSettingGroup = {\r\n            heading_setting: new Setting(setting_group_element)\r\n                .setName(\"\") // This will be set down below.\r\n                .setHeading()\r\n            ,\r\n            label_setting: new Setting(setting_group_element)\r\n                .setName(\"Field label\")\r\n                .addText(text => label_setting_component = text\r\n                    .setValue(prompt_field.configuration.label)\r\n                    .setPlaceholder(label_placeholders[label_placeholder_index])\r\n                    .onChange(async (new_label: string) => {\r\n                        prompt_field.configuration.label = new_label;\r\n                        _update_heading();\r\n                        await this.plugin.saveSettings();\r\n                    })\r\n                )\r\n            ,\r\n            default_value_setting: new Setting(setting_group_element)\r\n                .setName(\"Default value\")\r\n                .addText(text => text\r\n                    .setValue(prompt_field.configuration.default_value)\r\n                    .setPlaceholder(\r\n                        prompt_field.configuration.label ? \"\" // If the label is defined, do not add a placeholder here, as the label's placeholder is not visible, so this placeholder would not make sense.\r\n                            : default_value_placeholders_subset[randomInteger(0, default_value_placeholders_subset.length - 1)]\r\n                    )\r\n                    .onChange(on_default_value_setting_change)\r\n                )\r\n            ,\r\n            description_setting: new Setting(setting_group_element)\r\n                .setName(\"Description\")\r\n                .addText(text => description_setting_component = text\r\n                    .setValue(prompt_field.configuration.description)\r\n                    .onChange(async (new_description: string) => {\r\n                        prompt_field.configuration.description = new_description;\r\n                        await this.plugin.saveSettings();\r\n                    }),\r\n                )\r\n            ,\r\n            target_variable_setting: new Setting(setting_group_element)\r\n                .setName(\"Target variable\")\r\n                .setDesc(\"Where the inputted value will be stored in. You can use the variable in a shell command.\")\r\n                .addDropdown(dropdown => dropdown\r\n                    .addOption(\"\", \"\") // An option for a situation when nothing is selected.\r\n                    .addOptions(custom_variable_options)\r\n                    .addOption(\"new\", \"Create a new custom variable\")\r\n                    .setValue(prompt_field.configuration.target_variable_id)\r\n                    .onChange((new_target_variable_id: string) => {\r\n                        if (\"new\" === new_target_variable_id) {\r\n                            // Create a new custom variable.\r\n                            const model = getModel<CustomVariableModel>(CustomVariableModel.name);\r\n                            const custom_variable_instance = model.newInstance(this.plugin.settings);\r\n                            this.plugin.saveSettings().then(() => {\r\n                                const modal = new CustomVariableSettingsModal(\r\n                                    this.plugin,\r\n                                    custom_variable_instance,\r\n                                    async () => {\r\n                                        // Variable is created.\r\n                                        dropdown.addOption(custom_variable_instance.getID(), custom_variable_instance.getTitle());\r\n                                        dropdown.setValue(custom_variable_instance.getID());\r\n                                        prompt_field.configuration.target_variable_id = custom_variable_instance.getID();\r\n                                        await this.plugin.saveSettings();\r\n                                    },\r\n                                    async () => {\r\n                                        dropdown.setValue(prompt_field.configuration.target_variable_id); // Reset the dropdown selection.\r\n                                        // Variable creation was cancelled.\r\n                                        model.deleteInstance(custom_variable_instance);\r\n                                        await this.plugin.saveSettings();\r\n                                    },\r\n                                );\r\n                                modal.open();\r\n                            });\r\n                        } else {\r\n                            // Use an existing target variable (or an empty id \"\").\r\n                            // Check that this target variable is not reserved.\r\n                            prompt_field.setIfValid(\"target_variable_id\", new_target_variable_id).then(async () => {\r\n                                // It can be used.\r\n                                await this.plugin.saveSettings();\r\n                            }, (error_message: string | unknown) => {\r\n                                if (typeof error_message === \"string\") {\r\n                                    // This is a validation error message.\r\n                                    // The target variable is reserved.\r\n                                    dropdown.setValue(prompt_field.configuration.target_variable_id); // Reset the dropdown selection.\r\n                                    this.plugin.newNotification(error_message);\r\n                                } else {\r\n                                    // Some other runtime error has occurred.\r\n                                    throw error_message;\r\n                                }\r\n                            });\r\n                        }\r\n                    })\r\n                )\r\n            ,\r\n            required_setting: new Setting(setting_group_element)\r\n                .setName(\"Is required\")\r\n                .setDesc(\"If on, the field needs to be filled before the prompt can be submitted.\")\r\n                .addToggle(toggle => toggle\r\n                    .setValue(prompt_field.configuration.required)\r\n                    .onChange(async (new_required: boolean) => {\r\n                        prompt_field.configuration.required = new_required;\r\n                        await this.plugin.saveSettings();\r\n                    })\r\n                )\r\n            ,\r\n        };\r\n        _update_heading();\r\n\r\n        function _update_heading() {\r\n            setting_group.heading_setting.setName(prompt_field.getTitle());\r\n        }\r\n\r\n        // Autocomplete menu\r\n        if (this.plugin.settings.show_autocomplete_menu) {\r\n            // Show autocomplete menu (= a list of available variables).\r\n            const label_input_element = setting_group.label_setting.controlEl.find(\"input\") as HTMLInputElement;\r\n            createAutocomplete(this.plugin, label_input_element, () => label_setting_component.onChanged());\r\n            const default_value_input_element = setting_group.default_value_setting.controlEl.find(\"input\") as HTMLInputElement;\r\n            createAutocomplete(this.plugin, default_value_input_element, on_default_value_setting_change);\r\n            const description_input_element = setting_group.description_setting.controlEl.find(\"input\") as HTMLInputElement;\r\n            createAutocomplete(this.plugin, description_input_element, () => description_setting_component.onChanged());\r\n        }\r\n\r\n        return setting_group.heading_setting;\r\n    }\r\n\r\n    public validateValue(prompt_field: PromptField, field: keyof PromptFieldConfiguration, value: unknown): Promise<void> {\r\n        switch (field) {\r\n            case \"target_variable_id\": {\r\n                const new_target_variable_id: string = value as string; // A more descriptive name for 'value'.\r\n\r\n                // Always allow an empty target_variable_id. A Prompt cannot be opened if a field lacks a target_variable_id, but it's allowed to be stored in the configuration, because new Prompts cannot have a default selected target variable.\r\n                if (\"\" === new_target_variable_id) {\r\n                    return Promise.resolve();\r\n                }\r\n\r\n                // Check that the target variable is not used by other fields of the same Prompt.\r\n                for (const other_prompt_field of prompt_field.prompt.prompt_fields) {\r\n                    if (prompt_field !== other_prompt_field) { // Do not check the same field. Only check other fields.\r\n                        // Check if this other field has the same target variable.\r\n                        if (new_target_variable_id === other_prompt_field.configuration.target_variable_id) {\r\n                            // They have the same target_variable_id.\r\n                            // Return an error message.\r\n                            const targetVariableInstance: CustomVariableInstance | undefined = this.plugin.getCustomVariableInstances().get(new_target_variable_id);\r\n                            if (undefined === targetVariableInstance) {\r\n                                throw new Error(\"Could not find target variable with id \" + new_target_variable_id);\r\n                            }\r\n                            const target_variable_name = targetVariableInstance.getFullName();\r\n                            return Promise.reject(`Target variable ${target_variable_name} is already used by another field in the same prompt. Select another variable.`);\r\n                        }\r\n                    }\r\n                }\r\n                // All fields have been checked and no collisions were found.\r\n                return Promise.resolve();\r\n            } default: {\r\n                // No validation for other fields.\r\n                throw new Error(this.constructor.name + \".validateValue(): No validation is implemented for other fields.\");\r\n            }\r\n        }\r\n    }\r\n\r\n    public getDefaultConfiguration(): PromptFieldConfiguration {\r\n        return {\r\n            // type: \"text\",\r\n            label: \"\",\r\n            description: \"\",\r\n            default_value: \"\",\r\n            //  TODO: Add 'placeholder'.\r\n            target_variable_id: \"\",\r\n            required: true,\r\n        };\r\n    }\r\n\r\n    protected _deleteInstance(prompt_field: PromptField): void {\r\n        prompt_field.prompt.prompt_fields.delete(prompt_field);\r\n    }\r\n}\r\n\r\nexport class PromptFieldSet extends Set<PromptField> {}\r\n\r\nexport interface PromptFieldSettingGroup {\r\n    heading_setting: Setting;\r\n    label_setting: Setting;\r\n    default_value_setting: Setting;\r\n    description_setting: Setting;\r\n    target_variable_setting: Setting\r\n    required_setting: Setting;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    Setting,\r\n    TextComponent,\r\n} from \"obsidian\";\r\nimport {createAutocomplete} from \"../../../settings/setting_elements/Autocomplete\";\r\nimport SC_Plugin from \"../../../main\";\r\nimport {SC_Event} from \"../../../events/SC_Event\";\r\nimport {parseVariables} from \"../../../variables/parseVariables\";\r\nimport {TShellCommand} from \"../../../TShellCommand\";\r\nimport {\r\n    PromptField,\r\n} from \"../../../imports\";\r\n\r\nexport class PromptField_Text extends PromptField {\r\n\r\n    private text_component: TextComponent;\r\n\r\n    protected async _createField(container_element: HTMLElement, t_shell_command: TShellCommand | null, sc_event: SC_Event | null) {\r\n        const plugin: SC_Plugin = this.prompt.model.plugin;\r\n\r\n        // Create the field\r\n        const on_change = () => this.valueHasChanged(t_shell_command, sc_event);\r\n        const label_parsing_result = await parseVariables(this.prompt.model.plugin, this.configuration.label, null, t_shell_command, sc_event);\r\n        const description_parsing_result = await parseVariables(this.prompt.model.plugin, this.configuration.description, null, t_shell_command, sc_event);\r\n        const setting = new Setting(container_element)\r\n            .setName(label_parsing_result.succeeded ? label_parsing_result.parsed_content as string : label_parsing_result.original_content)\r\n            .setDesc(description_parsing_result.succeeded ? description_parsing_result.parsed_content as string : description_parsing_result.original_content)\r\n            .addText((text_component) => {\r\n                this.text_component = text_component;\r\n                text_component.onChange(on_change);\r\n            })\r\n        ;\r\n\r\n        // Set up onFocus hook.\r\n        this.text_component.inputEl.onfocus = () => {\r\n            this.hasGottenFocus();\r\n        };\r\n\r\n        // Show autocomplete menu (if enabled)\r\n        if (plugin.settings.show_autocomplete_menu) {\r\n            const input_element = setting.controlEl.find(\"input\") as HTMLInputElement;\r\n            createAutocomplete(plugin, input_element, on_change);\r\n        }\r\n    }\r\n\r\n    protected setValue(value: string): void {\r\n        this.text_component.setValue(value);\r\n    }\r\n\r\n    protected getValue(): string {\r\n        return this.text_component.getValue();\r\n    }\r\n\r\n    public setFocus(): void {\r\n        this.text_component.inputEl.focus();\r\n    }\r\n\r\n    protected isFilled(): boolean {\r\n        return this.getValue().length > 0;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../../main\";\r\nimport {ShellCommandParsingProcess, TShellCommand} from \"../../TShellCommand\";\r\nimport {SC_MainSettings} from \"../../settings/SC_MainSettings\";\r\nimport {SC_Event} from \"../../events/SC_Event\";\r\nimport {\r\n    getModel,\r\n    Instance,\r\n    PromptField,\r\n    PromptFieldConfiguration,\r\n    PromptFieldSet,\r\n    PromptFieldModel,\r\n    PromptModal,\r\n    PromptModel,\r\n    getIDGenerator,\r\n} from \"../../imports\";\r\nimport {debugLog} from \"../../Debug\";\r\n\r\nexport class Prompt extends Instance {\r\n\r\n    public prompt_fields: PromptFieldSet = new PromptFieldSet();\r\n\r\n    constructor(\r\n        public model: PromptModel,\r\n        protected plugin: SC_Plugin,\r\n        public configuration: PromptConfiguration,\r\n        public parent_configuration: SC_MainSettings,\r\n    ) {\r\n        super(model, configuration, parent_configuration);\r\n\r\n        // Introduce the ID to an ID generator so that it won't accidentally generate the same ID again when creating new Prompts.\r\n        getIDGenerator().addReservedID(configuration.id);\r\n\r\n        this.createFields();\r\n    }\r\n\r\n\r\n    public getID() {\r\n        return this.configuration.id;\r\n    }\r\n\r\n    public getTitle() {\r\n        return this.configuration.title;\r\n    }\r\n\r\n    public getConfiguration() {\r\n        return this.configuration;\r\n    }\r\n\r\n    public getCSSClass(): string {\r\n        return Prompt.getCSSBaseClass() + \"-\" + this.getID();\r\n    }\r\n\r\n    public static getCSSBaseClass() {\r\n        return \"SC-prompt-modal\";\r\n    }\r\n\r\n    public getCSSClasses() {\r\n        return [\r\n            Prompt.getCSSBaseClass(),\r\n            this.getCSSClass(),\r\n        ];\r\n    }\r\n\r\n    /**\r\n     * @param t_shell_command Can be null, if wanted to just preview the Prompt modal without really executing a shell command. Inputted values will still be assigned to target variables.\r\n     * @param parsing_process\r\n     * @param sc_event\r\n     * @return Promise The boolean value tells whether the user wants to execute a shell command (true) or cancel (false).\r\n     */\r\n    public openPrompt(t_shell_command: TShellCommand | null, parsing_process: ShellCommandParsingProcess | null, sc_event: SC_Event | null): Promise<boolean> {\r\n        const can_open_prompt_result = this.canOpenPrompt();\r\n        if (true !== can_open_prompt_result) {\r\n            // Some error is preventing opening the prompt.\r\n            // A human-readable error message is contained in can_open_prompt_result.\r\n            debugLog(\"Could not open Prompt \" + this.getID() + \" because of error: \" + can_open_prompt_result);\r\n            this.plugin.newError(can_open_prompt_result);\r\n            return Promise.resolve(false); // false: Cancel execution (pretends that a user cancelled it, but it's ok).\r\n        }\r\n\r\n        debugLog(\"Opening Prompt \" + this.getID());\r\n\r\n        const modal = new PromptModal(\r\n            this.plugin,\r\n            this.prompt_fields,\r\n            t_shell_command,\r\n            parsing_process,\r\n            this,\r\n            sc_event,\r\n            () => {return this.validateFields();}\r\n        );\r\n        modal.open();\r\n        return modal.promise;\r\n    }\r\n\r\n    private canOpenPrompt(): true | string {\r\n\r\n        // Check that all PromptFields have a target variable defined.\r\n        for (const prompt_field of this.prompt_fields) {\r\n            if (!prompt_field.configuration.target_variable_id) {\r\n                return `Cannot open prompt '${this.getTitle()}': Field '${prompt_field.getTitle()}' does not have a target variable.`;\r\n            } else {\r\n                try {\r\n                    prompt_field.getTargetVariableInstance(); // Just try to get a CustomVariableInstance. No need to use it here, but if this fails, we know the variable is removed.\r\n                } catch (error) {\r\n                    return `Cannot open prompt '${this.getTitle()}': Field '${prompt_field.getTitle()}' uses a target variable which does not exist anymore.`;\r\n                }\r\n            }\r\n        }\r\n\r\n        // All ok.\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Creates PromptField instances, NOT setting fields!\r\n     */\r\n    private createFields() {\r\n        debugLog(\"Creating fields for Prompt \" + this.getID());\r\n        const prompt_field_model = getModel<PromptFieldModel>(PromptFieldModel.name);\r\n        this.prompt_fields = prompt_field_model.loadInstances(this);\r\n    }\r\n\r\n    /**\r\n     * Validates values in PromptField instances, NOT setting fields!\r\n     */\r\n    private validateFields(): Promise<void> {\r\n        debugLog(\"Validating fields for Prompt \" + this.getID());\r\n\r\n        // Iterate all fields and check their validity.\r\n        const error_messages: string[] = [];\r\n        this.prompt_fields.forEach((prompt_field: PromptField) => {\r\n\r\n            // Check if the field has parsing errors.\r\n            const parsing_errors: string[] = prompt_field.getParsingErrors();\r\n            for (const parsing_error of parsing_errors) {\r\n                // This field has parsing error(s).\r\n                error_messages.push(`'${prompt_field.getTitle()}': ` + parsing_error);\r\n            }\r\n\r\n            // Check other validity.\r\n            if (!prompt_field.validate()) {\r\n                // This field failed to validate.\r\n                // TODO: Change this so that the message will come from prompt_field.validate().\r\n                error_messages.push(`'${prompt_field.getTitle()}' needs to be filled.`);\r\n            }\r\n        });\r\n\r\n        // Return the result.\r\n        if (0 === error_messages.length) {\r\n            return Promise.resolve();\r\n        } else {\r\n            return Promise.reject(error_messages);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * When previewing a PromptModal, there is no real shell command available (because no shell command has triggered the\r\n     * PromptModal). This method creates just a dummy shell command string that imitates a command that would echo variable values.\r\n     */\r\n    public getExampleShellCommand(): string {\r\n        const variable_names: string[] = [];\r\n        for (const prompt_field of this.prompt_fields) {\r\n            variable_names.push(prompt_field.getTargetVariableInstance().getFullName());\r\n        }\r\n        return \"echo \"+variable_names.join(\" \");\r\n    }\r\n}\r\n\r\nexport interface PromptConfiguration {\r\n    id: string;\r\n    title: string;\r\n    description: string;\r\n    preview_shell_command: boolean;\r\n    fields: PromptFieldConfiguration[];\r\n    execute_button_text: string;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Modal} from \"../../SC_Modal\";\r\nimport {ShellCommandParsingProcess, TShellCommand} from \"../../TShellCommand\";\r\nimport SC_Plugin from \"../../main\";\r\nimport {Setting} from \"obsidian\";\r\nimport {SC_Event} from \"../../events/SC_Event\";\r\nimport {createMultilineTextElement} from \"../../Common\";\r\nimport {Variable, VariableValueResult} from \"../../variables/Variable\";\r\nimport {\r\n    Prompt,\r\n    PromptField,\r\n    PromptFieldSet,\r\n} from \"../../imports\";\r\nimport {\r\n    parseVariables,\r\n    ParsingResult,\r\n} from \"../../variables/parseVariables\";\r\n\r\nexport class PromptModal extends SC_Modal {\r\n\r\n    public promise: Promise<boolean>;\r\n    private user_confirmed_ok = false;\r\n    private resolve_promise: (value: (boolean | PromiseLike<boolean>)) => void;\r\n\r\n    constructor(\r\n        plugin: SC_Plugin,\r\n        private readonly prompt_fields: PromptFieldSet,\r\n        /** Can be null, if wanted to just preview the Prompt modal without really executing a shell command. Inputted values will still be assigned to target variables. */\r\n        private readonly t_shell_command: TShellCommand | null,\r\n        private readonly parsing_process: ShellCommandParsingProcess | null,\r\n        private readonly prompt: Prompt,\r\n        private sc_event: SC_Event | null,\r\n\r\n        /** A function that is called when a user clicks the execution button. This function should check the form elements' validity and return false if there are unfilled fields. */\r\n        private readonly validator: () => Promise<void>,\r\n    ) {\r\n        super(plugin);\r\n        this.promise = new Promise<boolean>((resolve) => {\r\n            this.resolve_promise = resolve;\r\n        });\r\n    }\r\n\r\n    public async onOpen() {\r\n        super.onOpen();\r\n\r\n        // Parse and display title\r\n        const title_parsing_result = await parseVariables(this.plugin, this.prompt.getTitle(), null, this.t_shell_command, this.sc_event);\r\n        this.setTitle(\r\n            title_parsing_result.succeeded\r\n            ? title_parsing_result.parsed_content as string\r\n            : title_parsing_result.original_content\r\n        );\r\n\r\n        // Parse and display description\r\n        if (this.prompt.configuration.description) {\r\n            const description_parsing_result: ParsingResult = await parseVariables(this.plugin, this.prompt.configuration.description, null, this.t_shell_command, this.sc_event);\r\n            const description: string =\r\n                description_parsing_result.succeeded\r\n                ? description_parsing_result.parsed_content as string\r\n                : description_parsing_result.original_content\r\n            ;\r\n            const description_element = createMultilineTextElement(\"p\", description, this.modalEl);\r\n            description_element.addClass(\"setting-item-description\"); // A CSS class defined by Obsidian.\r\n        }\r\n\r\n        // Preview the shell command (if wanted)\r\n        // TODO: Extract to a separate method, as this is a big block of code.\r\n        let update_shell_command_preview: (() => void) | null = null; // Stays null if .preview_shell_command is false.\r\n        let focused_prompt_field: PromptField | undefined;\r\n        if (this.prompt.getConfiguration().preview_shell_command) {\r\n            let shell_command_preview_text: string;\r\n            if (this.t_shell_command?.getAlias()) {\r\n                this.modalEl.createEl(\"p\", {text: this.t_shell_command.getAlias(), attr: {class: \"SC-no-margin\"}});\r\n            }\r\n\r\n            // Create \"Show variable values\" toggle\r\n            let preview_variable_values = true;\r\n            const variable_names_visible_icon = \"code-glyph\";\r\n            const variable_values_visible_glyph = \"price-tag-glyph\";\r\n            const preview_variable_values_setting = new Setting(this.modalEl)\r\n                .addExtraButton(button => button\r\n                    .setIcon(variable_values_visible_glyph)\r\n                    .setTooltip(\"Toggle showing variable names or values.\")\r\n                    .onClick(() => {\r\n                        preview_variable_values = !preview_variable_values;\r\n                        button.setIcon(\r\n                            preview_variable_values\r\n                            ? variable_values_visible_glyph\r\n                            : variable_names_visible_icon\r\n                        );\r\n                        if (null === update_shell_command_preview) {\r\n                            throw new Error(\"Toggle showing variable names or value: update_shell_command_preview function is not defined.\");\r\n                        }\r\n                        update_shell_command_preview();\r\n                    }),\r\n                )\r\n            ;\r\n\r\n            // Decide what text to use in the preview\r\n            const shellCommandParsingResult: ParsingResult | undefined = this.parsing_process?.getParsingResults().shell_command;\r\n            if (shellCommandParsingResult?.succeeded) {\r\n                // Show a real shell command. Use preparsed content (= content that might have some variables already parsed).\r\n                shell_command_preview_text = shellCommandParsingResult.parsed_content as string; // as string = if shellCommandParsingResult?.succeeded is true, then .parsed_content is always string.\r\n            } else if (this.t_shell_command) {\r\n                // Show a real shell command. No preparsed content is available. This content does not have any variables parsed yet.\r\n                shell_command_preview_text = this.t_shell_command.getShellCommand();\r\n            } else {\r\n                // Make up a fake \"shell command\" for previewing.\r\n                shell_command_preview_text = this.prompt.getExampleShellCommand();\r\n                this.modalEl.createEl(\"p\", {text: \"(This is not a real shell command, it's just an example for this preview when no real shell command is available.)\", attr: {class: \"SC-no-margin SC-small-font\"}});\r\n            }\r\n            this.modalEl.createEl(\"hr\");\r\n\r\n            // A function for handling preview text updates.\r\n            update_shell_command_preview = async () => {\r\n                let shell_command_preview_text_final = shell_command_preview_text;\r\n                if (preview_variable_values) {\r\n                    // The preview should show the VALUES.\r\n\r\n                    // Ensure the form fields do not contain any parsing errors. (If there are errors, an unparsed preview text will be shown).\r\n                    if (this.getPromptFieldsParsingErrors().length === 0) {\r\n                        // All fields are parsed ok (= individual parsing).\r\n                        // Insert the field values into the shell command preview by parsing the preview text.\r\n\r\n                        // Get current values from the prompt fields.\r\n                        const fresh_values = this.getPromptFieldsValues(); // These PromptField values are fresh, so not yet stored in the actual variables.\r\n\r\n\r\n                        // Parse variables in the shell command preview text.\r\n                        const parsing_result = await parseVariables(\r\n                            this.plugin,\r\n                            shell_command_preview_text,\r\n                            this.getShell(),\r\n                            this.t_shell_command,\r\n                            this.sc_event,\r\n                            undefined, // Use all variables.\r\n                            (variable: Variable, raw_value: VariableValueResult): void => {\r\n                                if (fresh_values.has(variable.variable_name)) {\r\n                                    // Change the value to the one in the prompt field.\r\n                                    raw_value.error_messages = []; // Remove any possible error messages.\r\n                                    raw_value.succeeded = true; // This needs to reflect that there are no error messages.\r\n                                    raw_value.value = fresh_values.get(variable.variable_name) as string; // It's always a string because fresh_values.has() is used above.\r\n                                }\r\n                                // No modifications.\r\n                            },\r\n                            (variable: Variable, escaped_value: string): string => {\r\n                                // Emphasize the value that came from the currently focused field.\r\n                                if (focused_prompt_field) {\r\n                                    if (variable.variable_name.toLocaleLowerCase() === focused_prompt_field.getTargetVariableInstance().getPrefixedName().toLocaleLowerCase()) {\r\n                                        // Make the value bold.\r\n                                        return `<strong>${escaped_value}</strong>`;\r\n                                    }\r\n                                }\r\n                                // No modifications.\r\n                                return escaped_value;\r\n                            },\r\n                        );\r\n                        if (parsing_result.succeeded) {\r\n                            shell_command_preview_text_final = parsing_result.parsed_content as string;\r\n                        }\r\n                    }\r\n                } else {\r\n                    // The preview should show the VARIABLE NAMES.\r\n                    if (focused_prompt_field) {\r\n                        const pattern = new RegExp(focused_prompt_field.getTargetVariable().getPattern(), \"igu\"); // i: case-insensitive; g: match all occurrences instead of just the first one. u: support 4-byte unicode characters too.\r\n                        shell_command_preview_text_final = shell_command_preview_text_final.replace(\r\n                            pattern,\r\n                            (replaceable_variable_name) => {\r\n                                return \"<strong>\" + replaceable_variable_name + \"</strong>\";\r\n                            },\r\n                        );\r\n                    }\r\n                }\r\n                preview_variable_values_setting.descEl.innerHTML = shell_command_preview_text_final;\r\n            };\r\n        }\r\n\r\n        // Create fields\r\n        let is_first_field = true;\r\n        for (const prompt_field of this.prompt_fields) {\r\n            await prompt_field.createField(\r\n                this.modalEl.createDiv({attr: {class: \"SC-setting-group\"}}),\r\n                this.t_shell_command,\r\n                this.sc_event\r\n            );\r\n            if (update_shell_command_preview) {\r\n                prompt_field.onChange(update_shell_command_preview);\r\n            }\r\n            prompt_field.onFocus((prompt_field: PromptField) => {\r\n                focused_prompt_field = prompt_field;\r\n                if (update_shell_command_preview) {\r\n                    update_shell_command_preview();\r\n                }\r\n            });\r\n            if (is_first_field) {\r\n                // Focus on the first field.\r\n                is_first_field = false;\r\n                prompt_field.setFocus();\r\n            }\r\n        }\r\n        if (update_shell_command_preview) {\r\n            // Set a preview text. Must be done after fields are created, because their values are accessed.\r\n            update_shell_command_preview();\r\n        }\r\n\r\n        // Tip about variables\r\n        let tip = \"\";\r\n        if (this.prompt_fields.size > 0) {\r\n            // TODO: When implementing different field types, add a check that the tip is only shown when there are text/numeric fields present.\r\n            // Only show the tip if this modal actually contains fields. Prompts can also be used as custom 'confirmation prompts' without any fields.\r\n            tip = \"Tip! You can use {{variables}} in text fields.\";\r\n        }\r\n\r\n        // Execute button\r\n        const execute_button_text_parsing_result = await parseVariables(this.plugin, this.prompt.configuration.execute_button_text, null, this.t_shell_command, this.sc_event);\r\n        const execute_button_text =\r\n            execute_button_text_parsing_result.succeeded\r\n            ? execute_button_text_parsing_result.parsed_content as string\r\n            : execute_button_text_parsing_result.original_content\r\n        ;\r\n        new Setting(this.modalEl)\r\n            .setDesc(tip)\r\n            .addButton(button => button\r\n                .setButtonText(execute_button_text)\r\n                .onClick(() => this.approve())\r\n            )\r\n        ;\r\n\r\n        if (!this.t_shell_command) {\r\n            // Notice that this is a preview only Prompt.\r\n            this.modalEl.createEl(\"p\", {text: `This is a preview prompt. No shell command will be executed, but clicking the '${this.prompt.configuration.execute_button_text}' button will still store the inputted value(s) to variable(s).`}).addClass(\"SC-prompt-dry-run-notice\");\r\n        }\r\n\r\n        // Add CSS classes so that custom styling can be done on a per-prompt modal basis (or for all prompt modals via a common class).\r\n        this.modalEl.addClasses(this.prompt.getCSSClasses());\r\n    }\r\n\r\n    protected approve(): void {\r\n        this.validator().then(async () => {\r\n            // The form fields are filled ok\r\n            await this.assignValuesToVariables();\r\n            this.resolve_promise(true);\r\n            this.user_confirmed_ok = true;\r\n            this.close();\r\n        }, (error_messages: string[] | unknown) => {\r\n            if (Array.isArray(error_messages)) {\r\n                // There were some problems with the fields.\r\n                this.plugin.newErrors(error_messages);\r\n            } else {\r\n                // Some other runtime error has occurred.\r\n                throw error_messages;\r\n            }\r\n        });\r\n    }\r\n\r\n    public onClose(): void {\r\n        super.onClose();\r\n\r\n        if (!this.user_confirmed_ok) { // TODO: Find out if there is a way to not use this kind of flag property. Can the status be checked from the promise itself?\r\n            this.resolve_promise(false);\r\n        }\r\n    }\r\n\r\n    private async assignValuesToVariables() {\r\n        let promptField: PromptField;\r\n        for (promptField of this.prompt_fields) {\r\n            await promptField.getTargetVariable().setValue(promptField.getParsedOrRawValue());\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gathers a Map of variable values typed in the form, but does not store the values into the variables. Called when\r\n     * generating a preview text, so the result of this method will not persist in any way.\r\n     * @private\r\n     */\r\n    private getPromptFieldsValues() {\r\n        const values = new Map<string, string>();\r\n        for (const prompt_field of this.prompt_fields) {\r\n            values.set(prompt_field.getTargetVariable().variable_name, prompt_field.getParsedValue() ?? \"\"); // TODO: Should getParsedValue() ?? \"\" be changed to getParsedOrRawValue(), too?\r\n        }\r\n        return values;\r\n    }\r\n\r\n    private getPromptFieldsParsingErrors() {\r\n        const parsing_errors: string[] = [];\r\n        for (const prompt_field of this.prompt_fields) {\r\n            parsing_errors.push(...prompt_field.getParsingErrors());\r\n        }\r\n        return parsing_errors;\r\n    }\r\n\r\n    private getShell() {\r\n        if (this.t_shell_command) {\r\n            // This is a real usage of the PromptModal, so a TShellCommand is available. Look up the shell from that.\r\n            return this.t_shell_command.getShell();\r\n        } else {\r\n            // Just trying the PromptModal. Just use some shell for variable escaping in an example preview.\r\n            return this.plugin.getDefaultShell();\r\n        }\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    getIDGenerator,\r\n    Model,\r\n    ParentModelOneToManyIdRelation,\r\n    Preaction_Prompt_Configuration,\r\n    Prompt,\r\n    PromptConfiguration,\r\n    PromptSettingsModal,\r\n} from \"../../imports\";\r\nimport {Setting} from \"obsidian\";\r\nimport {SC_MainSettings} from \"../../settings/SC_MainSettings\";\r\nimport {debugLog} from \"../../Debug\";\r\n\r\nexport class PromptModel extends Model {\r\n\r\n    private prompts = new PromptMap();\r\n\r\n    public getSingularName(): string {\r\n        return \"Prompt\";\r\n    }\r\n\r\n    protected defineParentConfigurationRelation(prompt: Prompt): ParentModelOneToManyIdRelation {\r\n        return {\r\n            type: \"one-to-many-id\",\r\n            key: \"prompts\",\r\n            id: prompt.getID(),\r\n        };\r\n    }\r\n\r\n    public loadInstances(parent_configuration: SC_MainSettings): PromptMap {\r\n        debugLog(\"Loading Prompt instances.\");\r\n        this.prompts = new PromptMap();\r\n        parent_configuration.prompts.forEach((prompt_configuration: PromptConfiguration) => {\r\n            const prompt: Prompt = new Prompt(this, this.plugin, prompt_configuration, parent_configuration);\r\n            this.prompts.set(prompt_configuration.id, prompt);\r\n        });\r\n        return this.prompts;\r\n    }\r\n\r\n    public newInstance(parent_configuration: SC_MainSettings): Prompt {\r\n        debugLog(\"Creating a new Prompt instance.\");\r\n        // TODO: Move this logic to the base Model class.\r\n\r\n        // Setup a default configuration and generate an ID\r\n        const prompt_configuration = this.getDefaultConfiguration();\r\n\r\n        // Instantiate a Prompt\r\n        const prompt = new Prompt(this, this.plugin, prompt_configuration, this.plugin.settings);\r\n        this.prompts.set(prompt.getID(), prompt);\r\n\r\n        // Store the configuration into plugin's settings\r\n        this.plugin.settings.prompts.push(prompt_configuration);\r\n\r\n        // Return the Prompt\r\n        return prompt;\r\n\r\n    }\r\n\r\n    protected _createSettingFields(prompt: Prompt, container_element: HTMLElement): Setting {\r\n        debugLog(\"Creating setting fields for a Prompt instance.\");\r\n        const prompt_name_setting = new Setting(container_element)\r\n            // Configuration button\r\n            .setName(prompt.getTitle())\r\n            .addExtraButton(button => button\r\n                .setTooltip(\"Define prompt fields\")\r\n                .setIcon(\"gear\")\r\n                .onClick(() => {\r\n                    this.openSettingsModal(prompt, prompt_name_setting);\r\n                }),\r\n            )\r\n        ;\r\n        return prompt_name_setting;\r\n    }\r\n\r\n    public validateValue(prompt: Prompt, field: string, value: unknown): Promise<void> {\r\n        // This method is not used, so it can just resolve all the time.\r\n        return Promise.resolve(undefined);\r\n    }\r\n\r\n    public openSettingsModal(prompt: Prompt, prompt_name_setting: Setting) {\r\n        debugLog(\"Opening settings modal for a Prompt instance.\");\r\n        const modal = new PromptSettingsModal(this.plugin, prompt, prompt_name_setting);\r\n        modal.open();\r\n    }\r\n\r\n    public getDefaultConfiguration(): PromptConfiguration {\r\n        return {\r\n            id: getIDGenerator().generateID(),\r\n            title: \"\",\r\n            description: \"\",\r\n            preview_shell_command: false,\r\n            fields: [],\r\n            execute_button_text: \"Execute\",\r\n        };\r\n    }\r\n\r\n    protected _deleteInstance(prompt: Prompt): void {\r\n        debugLog(\"Deleting a Prompt instance.\");\r\n\r\n        // Remove the Prompt from all TShellCommands that use it.\r\n        const shell_commands = this.plugin.getTShellCommands();\r\n        for (const shell_command_id in shell_commands) {\r\n            const t_shell_command = shell_commands[shell_command_id];\r\n            for (const preaction_configuration of t_shell_command.getConfiguration().preactions) {\r\n                if (\"prompt\" === preaction_configuration.type) {\r\n                    const preaction_prompt_configuration = preaction_configuration as Preaction_Prompt_Configuration;\r\n                    if (prompt.getID() === preaction_prompt_configuration.prompt_id) {\r\n                        // This TShellCommand uses this Prompt.\r\n                        // Remove the Prompt from use.\r\n                        preaction_prompt_configuration.enabled = false;\r\n                        preaction_prompt_configuration.prompt_id = undefined;\r\n                        t_shell_command.resetPreactions();\r\n                        // Saving is done later, after the _deleteInstance() call.\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        this.prompts.delete(prompt.getID());\r\n    }\r\n}\r\n\r\nexport class PromptMap extends Map<string, Prompt> {}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../main\";\r\nimport {Setting} from \"obsidian\";\r\nimport {debugLog} from \"../Debug\";\r\nimport {\r\n    getModel,\r\n    Instance,\r\n    Model,\r\n} from \"../imports\";\r\n\r\n/**\r\n * @return Promise<InstanceClass> A promise that gets resolved if a user clicks the button. The promise is supplied with the newly created instance.\r\n */\r\nexport function createNewModelInstanceButton<\r\n        ModelClass extends Model,\r\n        InstanceClass extends Instance,\r\n    >(\r\n        plugin: SC_Plugin,\r\n        model_class_name: string,\r\n        button_container_element: HTMLElement,\r\n        instance_container_element: HTMLElement,\r\n        parent_instance_or_configuration: InstanceClass[\"parent_configuration\"] | InstanceClass[\"parent_instance\"]\r\n    ): Promise<{instance: InstanceClass, main_setting: Setting}> {\r\n\r\n    debugLog(\"Creating a button for creating a new instance for model \" + model_class_name + \".\");\r\n    return new Promise((resolve_promise) => {\r\n        const model = getModel<ModelClass>(model_class_name);\r\n        new Setting(button_container_element)\r\n            .addButton(button => button\r\n                .setButtonText(\"New \" + model.getSingularName().toLocaleLowerCase())\r\n                .onClick(async () => {\r\n                    if (null === parent_instance_or_configuration) {\r\n                        throw new Error(\"createNewModelInstanceButton(): Parent instance or configuration is null.\");\r\n                    }\r\n                    const instance = model.newInstance(parent_instance_or_configuration) as InstanceClass;\r\n                    const main_setting = model.createSettingFields(instance, instance_container_element);\r\n                    resolve_promise({\r\n                        \"instance\": instance,\r\n                        \"main_setting\": main_setting,\r\n                    });\r\n                    await plugin.saveSettings();\r\n                }),\r\n            )\r\n        ;\r\n    });\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Modal} from \"../../SC_Modal\";\r\nimport SC_Plugin from \"../../main\";\r\nimport {\r\n    Setting,\r\n    TextAreaComponent,\r\n    TextComponent,\r\n} from \"obsidian\";\r\nimport {createNewModelInstanceButton} from \"../createNewModelInstanceButton\";\r\nimport {\r\n    getModel,\r\n    Prompt,\r\n    PromptField,\r\n    PromptFieldModel,\r\n} from \"../../imports\";\r\nimport {createAutocomplete} from \"../../settings/setting_elements/Autocomplete\";\r\n\r\nexport class PromptSettingsModal extends SC_Modal {\r\n\r\n    private approved = false;\r\n\r\n    constructor(\r\n        plugin: SC_Plugin,\r\n        private readonly prompt: Prompt,\r\n\r\n        /** Can be undefined if the modal is created from a place where there is no name element. */\r\n        private readonly prompt_name_setting?: Setting,\r\n\r\n        /** If defined, a button will be added and on_after_approval() / on_after_cancelling() will be called depending on whether the button was clicked or not. */\r\n        private readonly ok_button_text?: string,\r\n        private readonly on_after_approval?: () => void,\r\n        private readonly on_after_cancelling?: () => void,\r\n    ) {\r\n        super(plugin);\r\n    }\r\n\r\n    public onOpen(): void {\r\n        super.onOpen();\r\n        const container_element = this.modalEl;\r\n        const title_and_description_group_element = container_element.createDiv({attr: {class: \"SC-setting-group\"}});\r\n\r\n        // Title\r\n        const title_setting = new Setting(title_and_description_group_element)\r\n            .setName(\"Prompt title\")\r\n            .addExtraButton(icon => icon\r\n                .setTooltip(\"Try the prompt without executing any shell command.\")\r\n                .setIcon(\"run-command\")\r\n                .onClick(() => {\r\n                    // \"Dry run\" the Prompt\r\n                    this.prompt.openPrompt(null, null, null).then();\r\n                })\r\n            )\r\n            .addText(text => text\r\n                .setValue(this.prompt.getTitle())\r\n                .onChange(async (new_title: string) => {\r\n                    this.prompt.getConfiguration().title = new_title;\r\n                    await this.plugin.saveSettings();\r\n\r\n                    // Update the title in a name setting. (Only if the modal was created from a place where a Prompt name element exists).\r\n                    this.prompt_name_setting?.setName(new_title);\r\n                })\r\n                .then((title_setting_component: TextComponent) => {\r\n                    // Autocomplete for Title.\r\n                    if (this.plugin.settings.show_autocomplete_menu) {\r\n                        createAutocomplete(this.plugin, title_setting_component.inputEl, () => title_setting_component.onChanged());\r\n                    }\r\n                }),\r\n            )\r\n        ;\r\n        const title_input_element: HTMLInputElement = title_setting.controlEl.find(\"input\") as HTMLInputElement;\r\n        \r\n        // Focus on the title field.\r\n        title_input_element.focus();\r\n\r\n        // Description\r\n        new Setting(title_and_description_group_element)\r\n            .setName(\"Description\")\r\n            .setDesc(\"Displayed between the prompt title and fields. Both Description and Title support {{variables}}.\")\r\n            .addTextArea(textarea => textarea\r\n                .setValue(this.prompt.configuration.description)\r\n                .onChange(async (new_description: string) => {\r\n                    this.prompt.getConfiguration().description = new_description;\r\n                    await this.plugin.saveSettings();\r\n                })\r\n                .then((description_component: TextAreaComponent) => {\r\n                    // Autocomplete for Description.\r\n                    if (this.plugin.settings.show_autocomplete_menu) {\r\n                        createAutocomplete(this.plugin, description_component.inputEl, () => description_component.onChanged());\r\n                    }\r\n                }),\r\n            )\r\n        ;\r\n\r\n        // Preview shell command\r\n        new Setting(container_element)\r\n            .setName(\"Preview shell command in prompt\")\r\n            .setDesc(\"If this is on, the prompt will display the executable shell command with variable names in it, and highlight the variable(s) that will be affected by the values inputted in the prompt.\")\r\n            .addToggle(toggle => toggle\r\n                .setValue(this.prompt.getConfiguration().preview_shell_command)\r\n                .onChange(async (new_value: boolean) => {\r\n                    this.prompt.getConfiguration().preview_shell_command = new_value;\r\n                    await this.plugin.saveSettings();\r\n                }),\r\n            )\r\n        ;\r\n\r\n        // Fields\r\n        new Setting(container_element)\r\n            .setName(\"Fields\")\r\n            .setDesc(\"Tip! You can use {{variables}} in 'Field label', 'Default value' and 'Description'.\")\r\n        ;\r\n        const prompt_field_model = getModel<PromptFieldModel>(PromptFieldModel.name);\r\n        const fields_container = container_element.createDiv();\r\n        this.prompt.prompt_fields.forEach((prompt_field: PromptField) => {\r\n            prompt_field_model.createSettingFields(prompt_field, fields_container);\r\n        });\r\n\r\n        // New field button\r\n        createNewModelInstanceButton<PromptFieldModel, PromptField>(this.plugin, PromptFieldModel.name, container_element, fields_container, this.prompt).then();\r\n\r\n        // Execute button text\r\n        new Setting(container_element.createDiv({attr: {class: \"SC-setting-group\"}}))\r\n            .setName(\"Execute button text\")\r\n            .addText(text => text\r\n                .setValue(this.prompt.configuration.execute_button_text)\r\n                .onChange(async (new_execute_button_text) => {\r\n                    this.prompt.configuration.execute_button_text = new_execute_button_text;\r\n                    await this.plugin.saveSettings();\r\n                })\r\n                .then((execute_button_text_component: TextComponent) => {\r\n                    // Autocomplete for the Execute button text.\r\n                    if (this.plugin.settings.show_autocomplete_menu) {\r\n                        createAutocomplete(this.plugin, execute_button_text_component.inputEl, () => execute_button_text_component.onChanged());\r\n                    }\r\n                }),\r\n            )\r\n        ;\r\n\r\n\r\n        // Ok button\r\n        const okButtonText: string | undefined = this.ok_button_text;\r\n        if (okButtonText) {\r\n            new Setting(container_element)\r\n                .addButton(button => button\r\n                    .setButtonText(okButtonText)\r\n                    .onClick(() => this.approve()),\r\n                )\r\n            ;\r\n        }\r\n\r\n        // A tip about CSS styling.\r\n        new Setting(container_element)\r\n            .setDesc(\"Tip! You can customise the style of the prompt modal with CSS by using the class .\" + this.prompt.getCSSClass() + \" or .\" + Prompt.getCSSBaseClass()+\" (for all prompt modals).\")\r\n        ;\r\n    }\r\n\r\n    protected approve(): void {\r\n        if (this.on_after_approval) {\r\n            this.approved = true;\r\n            this.on_after_approval();\r\n        }\r\n        this.close();\r\n    }\r\n\r\n    public onClose(): void {\r\n        super.onClose();\r\n\r\n        // Call a cancelling hook if one is defined (and if the closing happens due to cancelling, i.e. the ok button is NOT clicked).\r\n        if (!this.approved && this.on_after_cancelling) {\r\n            this.on_after_cancelling();\r\n        }\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    Setting,\r\n    TextAreaComponent,\r\n} from \"obsidian\";\r\nimport SC_Plugin from \"../../main\";\r\nimport {\r\n    IPlatformSpecificString,\r\n    PlatformId,\r\n    PlatformNames,\r\n} from \"../SC_MainSettings\";\r\nimport {\r\n    getOperatingSystem,\r\n    gotoURL,\r\n} from \"../../Common\";\r\nimport {ConfirmationModal} from \"../../ConfirmationModal\";\r\nimport {createAutocomplete} from \"./Autocomplete\";\r\nimport {DocumentationPATHAugmentationsLink} from \"../../Documentation\";\r\n\r\nexport function createPATHAugmentationFields(plugin: SC_Plugin, container_element: HTMLElement, path_augmentations: IPlatformSpecificString) {\r\n\r\n    const path_variable_name = getPATHEnvironmentVariableName();\r\n    new Setting(container_element)\r\n        .setName(`Add directories to the ${path_variable_name} environment variable`)\r\n        .setHeading()\r\n        .setDesc(`This is sometimes needed in order to be able to call some user installed applications. The directories will be appended AFTER the default directories in ${path_variable_name}, unless {{!environment:${path_variable_name}}} is included. Other {{variables}} can be used, too, but they don't affect the appending order.`)\r\n\r\n        // An icon for showing the current PATH content.\r\n        .addExtraButton(button => button\r\n            .setIcon(\"bullet-list\")\r\n            .setTooltip(`Show the current ${path_variable_name} content (without any additions).`)\r\n            .onClick(() => {\r\n                if (undefined === process.env.PATH) {\r\n                    throw new Error(\"process.env.PATH is not a string.\");\r\n                }\r\n                const modal = new ConfirmationModal(\r\n                    plugin,\r\n                    `Current ${path_variable_name} content`,\r\n                    process.env.PATH,\r\n                    \"Close\",\r\n                );\r\n                modal.open();\r\n            }),\r\n        )\r\n\r\n        // Help link\r\n        .addExtraButton(button => button\r\n            .setIcon(\"help\")\r\n            .setTooltip(`Documentation: Additions to the ${path_variable_name} environment variable`)\r\n            .onClick(() => gotoURL(DocumentationPATHAugmentationsLink))\r\n        )\r\n    ;\r\n\r\n    // Create a field for each operating system.\r\n    const sub_container_element = container_element.createDiv();\r\n    sub_container_element.addClass(\"SC-setting-group\");\r\n    Object.getOwnPropertyNames(PlatformNames).forEach((platform_id: PlatformId) => { // Use .forEach() and callbacks instead of a simple for loop, because 'platform_id' needs to retain the same value later in the .onChange() callback. Otherwise, `platform_id` would show up as \"win32\" in all .onChange() calls.\r\n        const platform_name = PlatformNames[platform_id];\r\n\r\n        new Setting(sub_container_element).setName(platform_name + \" \" + getPATHEnvironmentVariableName(platform_id) + \" additions\")\r\n            .setDesc(\"Define each directory on a separate line, or multiple directories on one line, separated by \" + getPATHSeparator(platform_id, true))\r\n            .addTextArea(textarea => textarea\r\n                .setValue(path_augmentations[platform_id] ?? \"\")\r\n                .onChange(async (new_path_augmentation: string) => {\r\n                    // PATH augmentation has been changed.\r\n                    // Update the configuration.\r\n                    if (new_path_augmentation.length > 0) {\r\n                        // The augmentation has content.\r\n                        path_augmentations[platform_id] = new_path_augmentation;\r\n                    } else {\r\n                        // The augmentation has been removed.\r\n                        delete path_augmentations[platform_id];\r\n                    }\r\n                    await plugin.saveSettings();\r\n                })\r\n                .then((textarea_component: TextAreaComponent) => {\r\n                    // Add an autocomplete menu.\r\n                    createAutocomplete(plugin, textarea_component.inputEl as unknown as HTMLInputElement, () => textarea_component.onChanged());\r\n                })\r\n            );\r\n        });\r\n}\r\n\r\nexport function getPATHSeparator(platform_id: PlatformId, verbose = false) {\r\n    switch (platform_id) {\r\n        case \"linux\":\r\n        case \"darwin\": // This is macOS.\r\n            return verbose ? \"a colon :\" : \":\";\r\n        case \"win32\":\r\n            return verbose ? \"a semicolon ;\" : \";\";\r\n    }\r\n}\r\n\r\nexport function convertNewlinesToPATHSeparators(path: string, platform_id: PlatformId) {\r\n    const separator = getPATHSeparator(platform_id);\r\n    return path.replace(\r\n        /(\\r\\n|\\r|\\n)+/gu, // + means that multiple adjacent newlines can be combined into a single separator character.\r\n        () => separator, // The replacement is a callback in order to avoid problems with $ characters, although that problem would only occur if the separator would contain a $ character, which is does not, but fix it anyway.\r\n    );\r\n}\r\n\r\n/**\r\n * Retrieves a PATH environment variable augmentation string (specific to the current operating system) from the plugin's\r\n * configuration. Returns it WITHOUT parsing possible variables in the string. If the current operating system does not\r\n * have a dedicated PATH augmentation string in the configuration, returns null.\r\n *\r\n * @param plugin\r\n */\r\nexport function getPATHAugmentation(plugin: SC_Plugin): string | null {\r\n    return plugin.settings.environment_variable_path_augmentations[getOperatingSystem()] ?? null;\r\n}\r\n\r\n/**\r\n * Returns OS specific name for the PATH environment variable. For Windows its Path, but for macOS and Linux its PATH, so\r\n * the only difference is casing.\r\n */\r\nexport function getPATHEnvironmentVariableName(platform_id: PlatformId = getOperatingSystem()) {\r\n    switch (platform_id) {\r\n        case \"darwin\":\r\n        case \"linux\":\r\n            return \"PATH\";\r\n        case \"win32\":\r\n            return \"Path\";\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    parseVariables,\r\n    ParsingResult,\r\n} from \"./parseVariables\";\r\nimport SC_Plugin from \"../main\";\r\nimport {SC_Event} from \"../events/SC_Event\";\r\nimport {VariableSet} from \"./loadVariables\";\r\nimport {\r\n    cloneObject,\r\n    uniqueArray,\r\n} from \"../Common\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {debugLog} from \"../Debug\";\r\n\r\n/**\r\n * ParsingProcess instances can be used in situations where it's uncertain can all variables be parsed at the time being,\r\n * i.e. when parsing shell commands (and aliases), as they can have preactions which require parsing to be done in two phases.\r\n *\r\n * Also, shell commands are often parsed in advance for command palette and context menus. Then it's good to store the parsing\r\n * result by using instances of this class.\r\n *\r\n * Then again, if the parsing use-case is simpler, e.g. Prompt description or prompt field values, it's more straightforward\r\n * to just call parseVariables() without utilising this class. After all, this class is a wrapper for parseVariables().\r\n *\r\n * <ParsingMap> is a generalization for defining keys for an object that will be used for submitting the original parseable\r\n * content. The same keys will then be used to form another object containing the parsing results.\r\n */\r\nexport class ParsingProcess<ParsingMap extends {[key: string]: string}> {\r\n\r\n    private readonly parsing_results: ParsingResultContainer<ParsingMap> = {};\r\n\r\n    constructor(\r\n        private plugin: SC_Plugin,\r\n        private original_contents: ParsingMap,\r\n\r\n        /** Used to get a shell (getShell()) and default values for variables. */\r\n        private t_shell_command: TShellCommand,\r\n        private sc_event: SC_Event | null,\r\n\r\n        /**\r\n         * When .process() is called, it will shift and process the first VariableSet present in this array. So, the next call\r\n         * will shift and process the next set.\r\n         */\r\n        private variable_sets: VariableSet[],\r\n\r\n        /**\r\n         * This can be used to mark certain contents to always avoid escaping special characters in their variable values.\r\n         * This should only be used for content that is never submitted to a shell, i.e. output wrappers at the moment.\r\n         *\r\n         * This is a list of 'content keys'.\r\n         */\r\n        private avoid_escaping: (keyof ParsingMap)[] = [],\r\n    ) {\r\n        debugLog(\"Parsing process: Count variable sets: \" + this.variable_sets.length);\r\n    }\r\n\r\n    private is_first_call = true;\r\n    /**\r\n     * Performs the next step in the parsing process. The step can be the first one, or a subsequent step.\r\n     *\r\n     * @return True if parsing succeeded, false otherwise. Read the results by calling .getParsingResult().\r\n     */\r\n    public async process(): Promise<boolean> {\r\n        if (this.variable_sets.length === 0) {\r\n            throw new Error(\"No variable sets are left for processing.\");\r\n        }\r\n        const current_variables = this.variable_sets.shift() as VariableSet; // as VariableSet: Tell TypeScript that there is always a set of variables.\r\n        let success = true;\r\n\r\n        debugLog(\"Parsing process: Count variables in current set: \" + current_variables.size);\r\n\r\n        // Multiple contents can be parsed in the same call. TShellCommand instances have 'shell_command' and 'alias'\r\n        // contents which are parsed at the same time. This multi-content support can be used for even more situations if\r\n        // needed in the future.\r\n        for (const content_key of this.getContentKeys()) {\r\n\r\n            let parse_content: string;\r\n            if (this.is_first_call) {\r\n                // Use original content.\r\n                parse_content = this.original_contents[content_key];\r\n                debugLog(\"Starting to parse '\" + content_key + \"': \" + parse_content);\r\n            } else {\r\n                // Continue parsing content from previous parsing result. This time parse variables that were not parse back then.\r\n                // FIXME: Problem: variable values that came from an earlier phase are exposed to repetitive parsing. Find a way to limit the parsing to only original parts of the shell command.\r\n\r\n                const previousParsingResult: ParsingResult | undefined = this.parsing_results[content_key];\r\n                if (undefined === previousParsingResult) {\r\n                    // This is just a type guard. this.getContentKeys() should only return keys that exist, so the checks should never throw errors in practise.\r\n                    throw new Error(\"Parsing results do not contain key: \" + content_key);\r\n                }\r\n\r\n                // Check that the previous parsing did not fail.\r\n                if (null === previousParsingResult.parsed_content) {\r\n                    // Previous parsing had probably failed.\r\n                    throw new Error(\"Tried to continue parsing, but previous parsing result is null. Probably previous parsing has failed.\");\r\n                }\r\n\r\n                // Previous parsing was ok.\r\n                parse_content = previousParsingResult.parsed_content;\r\n                debugLog(\"Continuing parsing '\" + content_key + \"': \" + parse_content);\r\n            }\r\n\r\n            // Parse the variables\r\n            const parsing_result = await parseVariables(\r\n                this.plugin,\r\n                parse_content,\r\n                this.avoidEscaping(content_key) ? null : this.t_shell_command.getShell(), // If no escaping is needed, pass null.\r\n                this.t_shell_command,\r\n                this.sc_event,\r\n                current_variables,\r\n            );\r\n\r\n            // Check if the parsing succeeded or failed.\r\n            success = success && parsing_result.succeeded; // Flag as failed also if a previous phase has failed.\r\n\r\n            // Store the parsing result\r\n            this.mergeToParsingResults(content_key, parsing_result);\r\n        }\r\n\r\n        // Finish\r\n        this.is_first_call = false;\r\n        return success;\r\n    }\r\n\r\n    /**\r\n     * A wrapper for .process() that processes all the VariableSets that are still left unprocessed.\r\n     *\r\n     * @return True if parsing all sets succeeded, false otherwise.\r\n     */\r\n    public async processRest(): Promise<boolean> {\r\n        // 1. Check a previous parsing result (if exists).\r\n        for (const content_key of this.getContentKeys()) {\r\n            const parsingResult: ParsingResult | undefined = this.parsing_results[content_key];\r\n            if (parsingResult) {\r\n                // A previous parsing result exists.\r\n                // Ensure it has not failed.\r\n                debugLog(\"Previous parsing succeeded? \" + parsingResult.succeeded);\r\n                if (!parsingResult.succeeded) {\r\n                    // The previous parsing result has failed.\r\n                    return false;\r\n                }\r\n            }\r\n        }\r\n\r\n        // 2. Process the rest of the VariableSets.\r\n        for (let i = 0; i < this.variable_sets.length; i++) {\r\n            if (!await this.process()) {\r\n                return false;\r\n            }\r\n        }\r\n        return true;\r\n    }\r\n\r\n    public getParsingResults() {\r\n        return this.parsing_results;\r\n    }\r\n\r\n    /**\r\n     * Calls SC_Plugin.newErrors() to create visible error balloons for all the issues encountered during parsing.\r\n     */\r\n    public displayErrorMessages(): void {\r\n        this.plugin.newErrors(this.getErrorMessages());\r\n    }\r\n\r\n    /**\r\n     * @private Can be made public if needed.\r\n     */\r\n    private getErrorMessages() {\r\n        let error_messages: string[] = [];\r\n        for (const content_key of this.getContentKeys()) {\r\n            const parsingResult: ParsingResult | undefined = this.parsing_results[content_key];\r\n\r\n            // Type guard\r\n            if (undefined === parsingResult) {\r\n                // This should never happen, because this.getContentKeys() should only return existing keys.\r\n                throw new Error(\"Parsing result is undefined.\");\r\n            }\r\n\r\n            error_messages.push(\r\n                ...parsingResult.error_messages,\r\n            );\r\n        }\r\n\r\n        // Remove duplicate error messages. When parsing 'shell_command' and 'alias', they can contain same variables and\r\n        // therefore generate same error messages.\r\n        error_messages = uniqueArray(error_messages);\r\n\r\n        return error_messages;\r\n    }\r\n\r\n    private getContentKeys(): (keyof ParsingMap)[] {\r\n        return Object.getOwnPropertyNames(this.original_contents) as (keyof ParsingMap)[];\r\n    }\r\n\r\n    /**\r\n     * Merges consecutive parsing results together so that information from both the old and new parsing results can be preserved.\r\n     */\r\n    private mergeToParsingResults(content_key: keyof ParsingMap, newParsingResult: ParsingResult) {\r\n        const originalParsingResult: ParsingResult | undefined = this.parsing_results[content_key];\r\n        if (undefined === originalParsingResult) {\r\n            // No need to merge. But clone the object so that possible future merges will not mess up the original object\r\n            // in case it's used somewhere else.\r\n            this.parsing_results[content_key] = cloneObject(newParsingResult);\r\n            // Note that originalParsingResult is still undefined. If you continue writing code here or after the if block\r\n            // (near the end of the function), do something like originalParsingResult = this.parsing_results[content_key]\r\n            // but that would require changing originalParsingResult from const to let.\r\n        } else {\r\n            // Merge\r\n            // NOTE: originalParsingResult.original_content IS KEPT UNCHANGED! The newer \"original\" content is not actually original, because it's partly parsed. That's why the old one is preserved.\r\n            originalParsingResult.parsed_content = newParsingResult.parsed_content; // New parsed content overrides the old one.\r\n            originalParsingResult.succeeded &&= newParsingResult.succeeded; // Both the old and new parsing must have succeeded in order to consider the whole process succeeded.\r\n            originalParsingResult.error_messages.push(...newParsingResult.error_messages); // Include both old and new error messages.\r\n            originalParsingResult.count_parsed_variables += newParsingResult.count_parsed_variables; // Sum up the variable usage counts. At the time of writing, the sum is only used for determining if there were any variables parsed or not, so an accurate sum is not used atm.\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Tells whether the given content_key has a mark that special characters in the content's variable values should not be escaped.\r\n     *\r\n     * @param content_key\r\n     * @private\r\n     */\r\n    private avoidEscaping(content_key: keyof ParsingMap): boolean {\r\n        return this.avoid_escaping.contains(content_key);\r\n    }\r\n}\r\n\r\ntype ParsingResultContainer<ParsingMap> = {\r\n    [key in keyof ParsingMap]?: ParsingResult;\r\n};","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n    OutputChannelCodes,\r\n    OutputChannelOrder,\r\n    OutputHandlingMode,\r\n} from \"../output_channels/OutputChannelCode\";\r\nimport {\r\n    ICommandPaletteOptions,\r\n    IPlatformSpecificString,\r\n    IPlatformSpecificStringWithDefault,\r\n} from \"./SC_MainSettings\";\r\nimport {SC_EventConfigurations} from \"../events/SC_EventConfiguration\";\r\nimport {InheritableVariableDefaultValueConfiguration} from \"../variables/Variable\";\r\nimport {\r\n    PreactionConfiguration\r\n} from \"../imports\";\r\n\r\nexport interface ShellCommandConfiguration {\r\n    id: string,\r\n    /**\r\n     * Contains operating system specific shell commands.\r\n     *  - key: platform (= OS) name\r\n     *  - value: shell command\r\n     */\r\n    platform_specific_commands: IPlatformSpecificStringWithDefault;\r\n    shells: IPlatformSpecificString;\r\n    alias: string;\r\n    icon: string | null;\r\n    confirm_execution: boolean;\r\n    ignore_error_codes: number[];\r\n    input_contents: {\r\n        stdin: string | null,\r\n    },\r\n    output_channels: OutputChannelCodes,\r\n    output_wrappers: {\r\n        stdout: string | null,\r\n        stderr: string | null,\r\n    };\r\n    output_channel_order: OutputChannelOrder;\r\n    output_handling_mode: OutputHandlingMode;\r\n    events: SC_EventConfigurations;\r\n    command_palette_availability: keyof ICommandPaletteOptions;\r\n    preactions: PreactionConfiguration[];\r\n    variable_default_values: {\r\n        [variable_id_or_name: string]: InheritableVariableDefaultValueConfiguration,\r\n    };\r\n\r\n    // LEGACY\r\n    /** @deprecated Can only be used for migration. */\r\n    shell_command?: string;\r\n}\r\n\r\nexport function newShellCommandConfiguration(shell_command_id: string, shell_command = \"\"): ShellCommandConfiguration {\r\n    return {\r\n        id: shell_command_id,\r\n        platform_specific_commands: {\r\n            default: shell_command,\r\n        },\r\n        shells: {},\r\n        alias: \"\",\r\n        icon: null,\r\n        confirm_execution: false,\r\n        ignore_error_codes: [],\r\n        input_contents: {\r\n            stdin: null,\r\n        },\r\n        output_channels: {\r\n            stdout: \"ignore\",\r\n            stderr: \"notification\",\r\n        },\r\n        output_wrappers: {\r\n            stdout: null,\r\n            stderr: null,\r\n        },\r\n        output_channel_order: \"stdout-first\",\r\n        output_handling_mode: \"buffered\",\r\n        events: {},\r\n        command_palette_availability: \"enabled\",\r\n        preactions: [],\r\n        variable_default_values: {},\r\n    };\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"./main\";\r\nimport {newShellCommandConfiguration, ShellCommandConfiguration} from \"./settings/ShellCommandConfiguration\";\r\nimport {debugLog} from \"./Debug\";\r\nimport * as fs from \"fs\";\r\nimport {combineObjects, getPluginAbsolutePath} from \"./Common\";\r\nimport * as path from \"path\";\r\nimport {getDefaultSettings} from \"./settings/SC_MainSettings\";\r\nimport {\r\n    CustomVariableConfiguration,\r\n    CustomVariableModel,\r\n} from \"./models/custom_variable/CustomVariableModel\";\r\nimport {getModel} from \"./models/Model\";\r\n\r\nexport async function RunMigrations(plugin: SC_Plugin) {\r\n    const should_save = [ // If at least one of the values is true, saving will be triggered.\r\n        EnsureMainFieldsExist(plugin), // Do this early.\r\n        MigrateCommandsToShellCommands(plugin),\r\n        MigrateShellCommandsObjectToArray(plugin),\r\n        MigrateShellCommandToPlatforms(plugin),\r\n        EnsureShellCommandsHaveAllFields(plugin),\r\n        EnsureCustomVariablesHaveAllFields(plugin),\r\n        DeleteEmptyCommandsField(plugin),\r\n    ];\r\n    if (should_save.includes(true)) {\r\n        // Only save if there were changes to configuration.\r\n        debugLog(\"Saving migrations...\");\r\n        backupSettingsFile(plugin); // Make a backup copy of the old file BEFORE writing the new, migrated settings file.\r\n        await plugin.saveSettings();\r\n        debugLog(\"Migrations saved...\");\r\n    }\r\n}\r\n\r\n/**\r\n * Can be removed in the future, but I haven't yet decided will it be done in 1.0 or later.\r\n */\r\nfunction MigrateShellCommandsObjectToArray(plugin: SC_Plugin) {\r\n    // Check if the shell commands' container is an object.\r\n    if (!Array.isArray(plugin.settings.shell_commands)) {\r\n        // It is an object. It needs to be changed to an array in order to allow custom ordering.\r\n        const shell_commands_array: ShellCommandConfiguration[] = [];\r\n        for (const shell_command_id of Object.getOwnPropertyNames(plugin.settings.shell_commands)) { // Remember that plugin.settings.shell_commands is an object here! Not an array (yet).\r\n            // @ts-ignore I don't know why TypeScript thinks the index is incorrect.\r\n            const shell_command_configuration: ShellCommandConfiguration = plugin.settings.shell_commands[shell_command_id];\r\n\r\n            // Assign 'id' to ShellCommandConfiguration because it did not contain it before this migration.\r\n            shell_command_configuration.id = shell_command_id;\r\n\r\n            // Add the ShellCommandConfiguration to the new array container.\r\n            shell_commands_array.push(shell_command_configuration);\r\n        }\r\n\r\n        // Replace the old object container with the new array container.\r\n        plugin.settings.shell_commands = shell_commands_array; // Now plugin.settings.shell_commands changes to be an array instead of an object.\r\n\r\n        return true; // Save the changes.\r\n    } else {\r\n        // The container is already migrated.\r\n        return false; // No need to save anything.\r\n    }\r\n}\r\n\r\n/**\r\n * Can be removed in 1.0.0.\r\n *\r\n * @param plugin\r\n * @constructor\r\n */\r\nfunction MigrateCommandsToShellCommands(plugin: SC_Plugin) {\r\n    if (undefined === plugin.settings.commands) {\r\n        return false;\r\n    }\r\n    const count_shell_commands = plugin.settings.commands.length;\r\n    let save = false;\r\n    if (0 < count_shell_commands) {\r\n        let count_empty_commands = 0; // A counter for empty or null commands\r\n        debugLog(\"settings.commands is not empty, will migrate \" + count_shell_commands + \" commands to settings.shell_commands.\");\r\n        for (const shell_command_id in plugin.settings.commands) {\r\n            const shell_command = plugin.settings.commands[shell_command_id];\r\n            // Ensure that the command is not empty. Just in case.\r\n            if (null === shell_command || 0 === shell_command.length) {\r\n                // The command is empty\r\n                debugLog(\"Migration failure for shell command #\" + shell_command_id + \": The original shell command string is empty, so it cannot be migrated.\");\r\n                count_empty_commands++;\r\n            }\r\n            else if (undefined !== plugin.getShellCommandConfigurationIndex(shell_command_id)) {\r\n                // A command with the same id already exists\r\n                debugLog(\"Migration failure for shell command #\" + shell_command_id + \": A shell command with same ID already exists in settings.shell_commands.\");\r\n            } else {\r\n                // All OK, migrate.\r\n                plugin.settings.shell_commands.push(newShellCommandConfiguration(shell_command_id, shell_command)); // Creates a shell command with default values and defines the command for it.\r\n                delete plugin.settings.commands[shell_command_id]; // Leaves a null in place, but we can deal with it by deleting the whole array if it gets empty.\r\n                count_empty_commands++; // Account the null generated on the previous line.\r\n                save = true;\r\n                debugLog(\"Migrated shell command #\" + shell_command_id + \": \" + shell_command);\r\n            }\r\n        }\r\n        if (count_empty_commands === count_shell_commands) {\r\n            // The whole commands array now contains only empty/null commands.\r\n            // Delete it.\r\n            delete plugin.settings.commands;\r\n        }\r\n    } else {\r\n        debugLog(\"settings.commands is empty, so no need to migrate commands. Good thing! :)\");\r\n    }\r\n    return save;\r\n}\r\n\r\n/**\r\n * This is a general migrator that adds new, missing properties to ShellCommandConfiguration objects. This is not tied to any specific version update, unlike MigrateCommandsToShellCommands().\r\n *\r\n * @param plugin\r\n * @constructor\r\n */\r\nfunction EnsureShellCommandsHaveAllFields(plugin: SC_Plugin) {\r\n    let save = false;\r\n    const shell_command_default_configuration = newShellCommandConfiguration(\"no-id\"); // Use a dummy id here, because something needs to be used. This id should never end up being used in practice.\r\n    const shell_command_configurations = plugin.settings.shell_commands;\r\n    for (const shell_command_configuration of shell_command_configurations) {\r\n        for (const property_name in shell_command_default_configuration) {\r\n            // @ts-ignore property_default_value can have (almost) whatever datatype\r\n            const property_default_value = shell_command_default_configuration[property_name];\r\n            // @ts-ignore\r\n            if (undefined === shell_command_configuration[property_name] && property_name !== \"id\") { // The \"id\" check is just in case that MigrateShellCommandsObjectToArray() would not have added the \"id\" property, in which case the dummy \"no-id\" id should not be accidentally assigned to the shell command.\r\n                // This shell command does not have this property.\r\n                // Add the property to the shell command and use a default value.\r\n                debugLog(\"EnsureShellCommandsHaveAllFields(): Shell command #\" + shell_command_configuration.id + \" does not have a property '\" + property_name + \"'. Will create the property and assign a default value '\" + property_default_value + \"'.\");\r\n                // @ts-ignore\r\n                shell_command_configuration[property_name] = property_default_value;\r\n                save = true;\r\n            }\r\n        }\r\n    }\r\n    return save;\r\n}\r\n\r\nfunction EnsureCustomVariablesHaveAllFields(plugin: SC_Plugin) {\r\n    let save = false;\r\n    const customVariableModel = getModel<CustomVariableModel>(CustomVariableModel.name);\r\n    const customVariableDefaultConfiguration: CustomVariableConfiguration = customVariableModel.getDefaultConfiguration();\r\n    let customVariableConfiguration: CustomVariableConfiguration;\r\n    for (customVariableConfiguration of plugin.settings.custom_variables) {\r\n        for (const propertyName in customVariableDefaultConfiguration) {\r\n            // @ts-ignore propertyDefaultValue can have (almost) whatever datatype\r\n            const propertyDefaultValue = customVariableDefaultConfiguration[propertyName];\r\n            // @ts-ignore\r\n            if (undefined === customVariableConfiguration[propertyName]) {\r\n                // This custom variable does not have this property.\r\n                // Add the property to it and use a default value.\r\n                debugLog(\"EnsureCustomVariablesHaveAllFields(): Custom variable #\" + customVariableConfiguration.id + \" does not have a property '\" + propertyName + \"'. Will create the property and assign a default value '\" + propertyDefaultValue + \"'.\");\r\n                // @ts-ignore\r\n                customVariableConfiguration[propertyName] = propertyDefaultValue;\r\n                save = true;\r\n            }\r\n        }\r\n    }\r\n    return save;\r\n}\r\n\r\n/**\r\n * This is a general migrator that adds new, missing properties to the main settings object. This is not tied to any specific version update, unlike MigrateCommandsToShellCommands().\r\n *\r\n * @param plugin\r\n * @constructor\r\n */\r\nfunction EnsureMainFieldsExist(plugin: SC_Plugin) {\r\n    let has_missing_fields = false;\r\n    const settings = plugin.settings;\r\n    const default_settings = getDefaultSettings(false);\r\n    for (const property_name in default_settings) {\r\n        // @ts-ignore\r\n        if (undefined === settings[property_name]) {\r\n            // The settings object does not have this property.\r\n            // @ts-ignore property_default_value can have (almost) whatever datatype\r\n            const property_default_value = default_settings[property_name];\r\n            debugLog(\"EnsureMainFieldsExist(): Main settings does not have property '\" + property_name + \"'. Will later create the property and assign a default value '\" + property_default_value + \"'.\");\r\n            has_missing_fields = true;\r\n        }\r\n    }\r\n\r\n    if (has_missing_fields) {\r\n        debugLog(\"EnsureMainFieldsExist(): Doing the above-mentioned new field creations...\");\r\n        plugin.settings = combineObjects(default_settings, plugin.settings);\r\n        debugLog(\"EnsureMainFieldsExist(): Done.\");\r\n        return true; // Save the changes\r\n    }\r\n\r\n    debugLog(\"EnsureMainFieldsExist(): No new fields to create, all ok.\");\r\n    return false; // Nothing to save.\r\n}\r\n\r\n/**\r\n * Can be removed in 1.0.0.\r\n *\r\n * @param plugin\r\n * @constructor\r\n */\r\nfunction MigrateShellCommandToPlatforms(plugin: SC_Plugin) {\r\n    let save = false;\r\n    for (const shell_command_configuration of plugin.settings.shell_commands) {\r\n        if (undefined !== shell_command_configuration.shell_command) {\r\n            // The shell command should be migrated.\r\n            if (undefined === shell_command_configuration.platform_specific_commands || shell_command_configuration.platform_specific_commands.default === \"\") {\r\n                debugLog(\"Migrating shell command #\" + shell_command_configuration.id + \": shell_command string will be moved to platforms.default: \" + shell_command_configuration.shell_command);\r\n                shell_command_configuration.platform_specific_commands = {\r\n                    default: shell_command_configuration.shell_command,\r\n                };\r\n                delete shell_command_configuration.shell_command;\r\n                save = true;\r\n            } else {\r\n                debugLog(\"Migration failure for shell command #\" + shell_command_configuration.id + \": platforms exists already.\");\r\n            }\r\n        }\r\n    }\r\n    return save;\r\n}\r\n\r\n/**\r\n * Can be removed in 1.0.0.\r\n *\r\n * @param plugin\r\n * @constructor\r\n */\r\nfunction DeleteEmptyCommandsField(plugin: SC_Plugin) {\r\n    let save = false;\r\n    if (undefined !== plugin.settings.commands) {\r\n        if (plugin.settings.commands.length === 0) {\r\n            delete plugin.settings.commands;\r\n            save = true;\r\n        }\r\n    }\r\n    return save;\r\n}\r\n\r\n/**\r\n * Permanent, do not remove.\r\n *\r\n * @param plugin\r\n */\r\nfunction backupSettingsFile(plugin: SC_Plugin) {\r\n    // plugin.app.fileManager.\r\n    // @ts-ignore\r\n    const current_settings_version = (plugin.settings.settings_version === \"prior-to-0.7.0\") ? \"0.x\" : plugin.settings.settings_version;\r\n    const plugin_path = getPluginAbsolutePath(plugin);\r\n    const settings_file_path = path.join(plugin_path, \"data.json\");\r\n    const backup_file_path_without_extension = path.join(plugin_path, \"data-backup-version-\" + current_settings_version + \"-before-upgrading-to-\" + SC_Plugin.SettingsVersion);\r\n\r\n    // Check that the current settings file can be found.\r\n    if (!fs.existsSync(settings_file_path)) {\r\n        // Not found. Probably the vault uses a different config folder than .obsidian.\r\n        debugLog(\"backupSettingsFile(): Cannot find data.json\");\r\n        plugin.newError(\"Shell commands: Cannot create a backup of current settings file, because data.json is not found.\");\r\n        return;\r\n    }\r\n\r\n    let backup_file_path = backup_file_path_without_extension + \".json\";\r\n    let running_number = 1;\r\n    while (fs.existsSync(backup_file_path)) {\r\n        running_number++; // The first number will be 2.\r\n        backup_file_path = backup_file_path_without_extension + \"-\" + running_number + \".json\";\r\n        if (running_number >= 1000) {\r\n            // There is some problem with detecting existing/inexisting files.\r\n            // Prevent hanging the program in an eternal loop.\r\n            throw new Error(\"backupSettingsFile(): Eternal loop detected.\");\r\n        }\r\n    }\r\n    fs.copyFileSync(settings_file_path, backup_file_path);\r\n}\r\n\r\n// TODO: Add migration: shell command variable_default_values: if type is \"show-errors\", change it to \"inherit\", but only if old settings version was below 18.","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {IPlatformSpecificString, PlatformId, PlatformNames} from \"../SC_MainSettings\";\r\nimport {extractFileName, getOperatingSystem} from \"../../Common\";\r\nimport {getUsersDefaultShell, PlatformShells} from \"../../Shell\";\r\nimport {Setting} from \"obsidian\";\r\nimport SC_Plugin from \"../../main\";\r\n\r\nexport function createShellSelectionField(plugin: SC_Plugin, container_element: HTMLElement, shells: IPlatformSpecificString, is_global_settings: boolean) {\r\n    let platform_id: PlatformId;\r\n    for (platform_id in PlatformNames) {\r\n        const platform_name = PlatformNames[platform_id];\r\n        let options: Record<string, string>;\r\n        if (is_global_settings) {\r\n            const current_system_default = (getOperatingSystem() === platform_id) ? \" (\" + extractFileName(getUsersDefaultShell()) + \")\" : \"\";\r\n            options = {\"default\": \"Use system default\" + current_system_default};\r\n        } else {\r\n            options = {\"default\": \"Use default\"};\r\n        }\r\n        for (const shell_path in PlatformShells[platform_id]) {\r\n            // @ts-ignore // TODO: Get rid of these two ts-ignores.\r\n            const shell_name = PlatformShells[platform_id][shell_path];\r\n            // @ts-ignore\r\n            options[shell_path] = shell_name;\r\n        }\r\n        new Setting(container_element)\r\n            .setName(platform_name + (is_global_settings ? \" default shell\" : \" shell\"))\r\n            .setDesc((is_global_settings ? \"Can be overridden by each shell command. \" : \"\") + (\"win32\" === platform_id ? \"Powershell is recommended over cmd.exe, because this plugin does not support escaping variables in CMD.\" : \"\"))\r\n            .addDropdown(dropdown => dropdown\r\n                .addOptions(options)\r\n                .setValue(shells[platform_id] ?? \"default\")\r\n                .onChange(((_platform_id: PlatformId) => {\r\n                    return async (value: string) => { // Need to use a nested function so that platform_id can be stored statically, otherwise it would always be \"win32\" (the last value of PlatformNames).\r\n                        if (\"default\" === value) {\r\n                            // When using default shell, the value should be unset.\r\n                            delete shells[_platform_id];\r\n                        } else {\r\n                            // Normal case: assign the shell value.\r\n                            shells[_platform_id] = value;\r\n                        }\r\n                        await plugin.saveSettings();\r\n                    };\r\n                })(platform_id))\r\n            )\r\n        ;\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../../main\";\r\nimport {TextAreaComponent} from \"obsidian\";\r\n\r\n/**\r\n * Makes a textarea grow and shrink based on the content height, and applies CSS styles on it to make it look more like an <input> element (not so much padding).\r\n */\r\nexport function decorateMultilineField(plugin: SC_Plugin, textareaComponent: TextAreaComponent, extraOnChange?: (content: string) => void) {\r\n\r\n    const textareaElement = textareaComponent.inputEl;\r\n\r\n    textareaElement.addClass(\"SC-multiline\");\r\n\r\n    const updateTextareaHeight = () => {\r\n        // Resize the shell command textarea to match the amount of lines in it.\r\n        const content = textareaElement.value;\r\n        const placeholder = textareaElement.placeholder;\r\n        const newlines_pattern = /\\r\\n|\\r|\\n/;\r\n        const count_lines_in_shell_command = content.split(newlines_pattern).length;\r\n        const count_lines_in_shell_command_placeholder = placeholder.split(newlines_pattern).length;\r\n        let count_lines_final = Math.max(\r\n            count_lines_in_shell_command,\r\n            count_lines_in_shell_command_placeholder,\r\n        );\r\n        if (plugin.settings.max_visible_lines_in_shell_command_fields) {\r\n            // Limit the height so that the field will not take up too much space.\r\n            count_lines_final = Math.min(\r\n                plugin.settings.max_visible_lines_in_shell_command_fields,\r\n                count_lines_final,\r\n            );\r\n        }\r\n        textareaElement.rows = count_lines_final;\r\n    };\r\n\r\n    updateTextareaHeight(); // Set a correct initial height.\r\n    textareaComponent.onChange(() => {\r\n        updateTextareaHeight(); // Update the height every time the field's value changes.\r\n        if (extraOnChange) {\r\n            extraOnChange(textareaElement.value);\r\n        }\r\n    });\r\n}\r\n\r\n","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport SC_Plugin from \"../../main\";\r\nimport {SettingFieldGroup} from \"../SC_MainSettingsTab\";\r\nimport {Setting} from \"obsidian\";\r\nimport {parseVariables} from \"../../variables/parseVariables\";\r\nimport {createAutocomplete} from \"./Autocomplete\";\r\nimport {SC_Event} from \"../../events/SC_Event\";\r\nimport {TShellCommand} from \"../../TShellCommand\";\r\nimport {createMultilineTextElement} from \"../../Common\";\r\nimport {EOL} from \"os\";\r\nimport {decorateMultilineField} from \"./multilineField\";\r\n\r\nexport function CreateShellCommandFieldCore(\r\n    plugin: SC_Plugin,\r\n    container_element: HTMLElement,\r\n    setting_icon_and_name: string,\r\n    shell_command: string,\r\n    shell: string,\r\n    t_shell_command: TShellCommand,\r\n    show_autocomplete_menu: boolean,\r\n    extra_on_change: (shell_command: string) => void,\r\n    shell_command_placeholder = \"Enter your command\"\r\n    ) {\r\n\r\n    async function on_change(shell_command: string) {\r\n        // Update preview\r\n        setting_group.preview_setting.descEl.innerHTML = \"\"; // Remove previous content.\r\n        createMultilineTextElement(\r\n            \"span\", // TODO: Maybe cleaner would be not to create a <span>, but to insert the content directly into descEl.\r\n            await getShellCommandPreview(plugin, shell_command, shell, t_shell_command, null /* No event is available during preview. */),\r\n            setting_group.preview_setting.descEl,\r\n        );\r\n\r\n        // Let the caller extend this onChange, to preform saving the settings:\r\n        extra_on_change(shell_command);\r\n    }\r\n\r\n    const setting_group: SettingFieldGroup = {\r\n        name_setting:\r\n            new Setting(container_element)\r\n                .setClass(\"SC-name-setting\")\r\n                .then((name_setting) => {\r\n                    name_setting.nameEl.innerHTML = setting_icon_and_name;\r\n                })\r\n        ,\r\n        shell_command_setting:\r\n            new Setting(container_element)\r\n                .addTextArea(textareaComponent => {\r\n                        textareaComponent\r\n                            .setPlaceholder(shell_command_placeholder)\r\n                            .setValue(shell_command)\r\n                        ;\r\n                        decorateMultilineField(plugin, textareaComponent, on_change);\r\n                    }\r\n                )\r\n                .setClass(\"SC-shell-command-setting\")\r\n        ,\r\n        preview_setting:\r\n            new Setting(container_element)\r\n                .setClass(\"SC-preview-setting\")\r\n                .then(async (setting: Setting) => {\r\n                    setting.descEl.innerHTML = \"\"; // Remove previous content. Not actually needed here because it's empty already, but do it just in case.\r\n                    createMultilineTextElement(\r\n                        \"span\", // TODO: Maybe cleaner would be not to create a <span>, but to insert the content directly into descEl.\r\n                        await getShellCommandPreview(plugin, shell_command, shell, t_shell_command, null /* No event is available during preview. */),\r\n                        setting.descEl,\r\n                    );\r\n                })\r\n        ,\r\n    };\r\n\r\n    // Autocomplete menu\r\n    if (show_autocomplete_menu) {\r\n        createAutocomplete(plugin, setting_group.shell_command_setting.settingEl.find(\"textarea\") as HTMLTextAreaElement, on_change);\r\n    }\r\n\r\n    return setting_group;\r\n}\r\n\r\n/**\r\n *\r\n * @param plugin\r\n * @param shell_command\r\n * @param shell\r\n * @param t_shell_command\r\n * @param sc_event\r\n * @public Exported because createShellCommandField uses this.\r\n */\r\nexport async function getShellCommandPreview(plugin: SC_Plugin, shell_command: string, shell: string, t_shell_command: TShellCommand, sc_event: SC_Event | null): Promise<string> {\r\n    const parsing_result = await parseVariables(plugin, shell_command, shell, t_shell_command, sc_event);\r\n    if (!parsing_result.succeeded) {\r\n        // Variable parsing failed.\r\n        if (parsing_result.error_messages.length > 0) {\r\n            // Return all error messages, each in its own line. (Usually there's just one message).\r\n            return parsing_result.error_messages.join(EOL); // Newlines are converted to <br>'s by the consumers of this function.\r\n        } else {\r\n            // If there are no error messages, then errors are silently ignored by user's variable configuration.\r\n            // The preview can then show the original, unparsed shell command.\r\n            return shell_command;\r\n        }\r\n    }\r\n    // Variable parsing succeeded\r\n    return parsing_result.parsed_content as string;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {CreateShellCommandFieldCore} from \"./CreateShellCommandFieldCore\";\r\nimport SC_Plugin from \"../../main\";\r\nimport {TShellCommand} from \"../../TShellCommand\";\r\nimport {PlatformId, PlatformNames} from \"../SC_MainSettings\";\r\n\r\nexport function createPlatformSpecificShellCommandField(plugin: SC_Plugin, container_element: HTMLElement, t_shell_command: TShellCommand, platform_id: PlatformId, show_autocomplete_menu: boolean) {\r\n    const platform_name = PlatformNames[platform_id];\r\n    const setting_group = CreateShellCommandFieldCore(\r\n        plugin,\r\n        container_element,\r\n        \"Shell command on \" + platform_name,\r\n        t_shell_command.getPlatformSpecificShellCommands()[platform_id] ?? \"\",\r\n        t_shell_command.getShell(),\r\n        t_shell_command,\r\n        show_autocomplete_menu,\r\n        async (shell_command: string) => {\r\n            if (shell_command.length) {\r\n                // shell_command is not empty, so it's a normal command.\r\n                t_shell_command.getPlatformSpecificShellCommands()[platform_id] = shell_command;\r\n            } else {\r\n                // shell_command is empty, so the default command should be used.\r\n                delete t_shell_command.getPlatformSpecificShellCommands()[platform_id];\r\n            }\r\n            await plugin.saveSettings();\r\n        },\r\n        t_shell_command.getDefaultShellCommand(),\r\n    );\r\n    setting_group.name_setting.setDesc(\"If empty, the default shell command will be used on \" + platform_name + \".\");\r\n    return setting_group;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {setIcon} from \"obsidian\";\r\n\r\nexport interface Tab {\r\n    title: string;\r\n    icon: string;\r\n    content_generator: (container_element: HTMLElement) => void;\r\n}\r\n\r\nexport interface TabStructure {\r\n    header: HTMLElement,\r\n    active_tab_id: string,\r\n    buttons: {\r\n        [key: string]: HTMLElement,\r\n    }\r\n    contentContainers: {\r\n        [key: string]: HTMLElement,\r\n    },\r\n}\r\n\r\nexport interface Tabs {\r\n    [key: string]: Tab;\r\n}\r\n\r\ninterface TabContentContainers {\r\n    [key: string]: HTMLElement,\r\n}\r\n\r\ninterface TabButtons {\r\n    [key: string]: HTMLElement,\r\n}\r\n\r\nexport function createTabs(container_element: HTMLElement, tabs: Tabs): TabStructure {\r\n    const tab_header = container_element.createEl(\"div\", {attr: {class: \"SC-tab-header\"}});\r\n    const tab_content_containers: TabContentContainers = {};\r\n    const tab_buttons: TabButtons = {};\r\n    const tab_structure = {\r\n        header: tab_header,\r\n        active_tab_id: Object.keys(tabs)[0] as string, // Indicate that the first tab is active. This does not affect what tab is active in practise, it just reports the active tab.\r\n        buttons: tab_buttons,\r\n        contentContainers: tab_content_containers,\r\n    };\r\n    let first_button: HTMLElement | undefined;\r\n    for (const tab_id in tabs) {\r\n        const tab = tabs[tab_id];\r\n\r\n        // Create button\r\n        const button = tab_header.createEl(\"button\", {\r\n            attr: {\r\n                class: \"SC-tab-header-button\",\r\n                activateTab: \"SC-tab-\" + tab_id,\r\n            },\r\n        });\r\n        button.onclick = function (event: MouseEvent) {\r\n            const tab_button = this as HTMLElement; // Use 'this' instead of event.target because this way we'll always get a button element, not an element inside the  button (i.e. an icon).\r\n\r\n            // Hide all tab contents and get the max dimensions\r\n            let max_width = 0;\r\n            let max_height = 0;\r\n            const tab_header = tab_button.parentElement;\r\n            if (null === tab_header) {\r\n                throw new Error(\"Tab header is missing. Did not get a parent from tab button.\");\r\n            }\r\n            const container_element = tab_header.parentElement;\r\n            if (null === container_element) {\r\n                throw new Error(\"Container element is missing. Did not get a parent from tab header.\");\r\n            }\r\n            const tab_contents = container_element.findAll(\"div.SC-tab-content\"); // Do not get all tab contents that exist, because there might be multiple tab systems open at the same time.\r\n            const is_main_settings_modal = container_element.hasClass(\"vertical-tab-content\");\r\n            for (const index in tab_contents) {\r\n                const tab_content = tab_contents[index];\r\n\r\n                // Get the maximum tab dimensions so that all tabs can have the same dimensions.\r\n                // But don't do it if this is the main settings modal\r\n                if (!is_main_settings_modal) {\r\n                    tab_content.addClass(\"SC-tab-active\"); // Need to make the tab visible temporarily in order to get the dimensions.\r\n                    if (tab_content.offsetHeight > max_height) {\r\n                        max_height = tab_content.offsetHeight;\r\n                    }\r\n                    if (tab_content.offsetWidth > max_width) {\r\n                        max_width = tab_content.offsetWidth;\r\n                    }\r\n                }\r\n\r\n                // Finally hide the tab\r\n                tab_content.removeClass(\"SC-tab-active\");\r\n            }\r\n\r\n            // Remove active status from all buttons\r\n            const adjacent_tab_buttons = tab_header.findAll(\".SC-tab-header-button\"); // Do not get all tab buttons that exist, because there might be multiple tab systems open at the same time.\r\n            for (const index in adjacent_tab_buttons) {\r\n                const tab_button = adjacent_tab_buttons[index];\r\n                tab_button.removeClass(\"SC-tab-active\");\r\n            }\r\n\r\n            // Activate the clicked tab\r\n            tab_button.addClass(\"SC-tab-active\");\r\n            const activateTabAttribute: Attr | null = tab_button.attributes.getNamedItem(\"activateTab\");\r\n            if (null === activateTabAttribute) {\r\n                throw new Error(\"Tab button has no 'activateTab' HTML attribute! Murr!\");\r\n            }\r\n            const activate_tab_id = activateTabAttribute.value;\r\n            const tab_content: HTMLElement | null = document.getElementById(activate_tab_id);\r\n            if (null === tab_content) {\r\n                throw new Error(\"No tab content was found with activate_tab_id '\"+activate_tab_id+\"'! Hmph!\");\r\n            }\r\n            tab_content.addClass(\"SC-tab-active\");\r\n\r\n            // Mark the clicked tab as active in TabStructure (just to report which tab is currently active)\r\n            tab_structure.active_tab_id = activate_tab_id.replace(/^SC-tab-/, \"\"); // Remove \"SC-tab\" prefix.\r\n\r\n            // Focus an element (if a focusable element is present)\r\n            tab_content.find(\".SC-focus-element-on-tab-opening\")?.focus(); // ? = If not found, do nothing.\r\n\r\n            // Apply the max dimensions to this tab\r\n            // But don't do it if this is the main settings modal\r\n            if (!is_main_settings_modal) {\r\n                tab_content.style.width = max_width + \"px\";\r\n                tab_content.style.height = max_height + \"px\";\r\n            }\r\n\r\n            // Do nothing else (I don't know if this is needed or not)\r\n            event.preventDefault();\r\n        };\r\n        setIcon(button, tab.icon);\r\n        button.insertAdjacentText(\"beforeend\", \" \" + tab.title);\r\n        tab_buttons[tab_id] = button;\r\n\r\n        // Create content container\r\n        tab_content_containers[tab_id] = container_element.createEl(\"div\", {attr: {class: \"SC-tab-content\", id: \"SC-tab-\" + tab_id}});\r\n\r\n        // Generate content\r\n        tab.content_generator(tab_content_containers[tab_id]);\r\n\r\n        // Memorize the first tab's button\r\n        if (undefined === first_button) {\r\n            first_button = button;\r\n        }\r\n    }\r\n\r\n    // Activate the first tab\r\n    if (undefined !== first_button) {\r\n        first_button.click();\r\n    }\r\n\r\n    // Return the TabStructure\r\n    return tab_structure;\r\n}\r\n\r\n","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\n// @ts-ignore\r\nimport {Setting} from \"obsidian\";\r\nimport SC_Plugin from \"../main\";\r\nimport {SC_MainSettingsTab} from \"./SC_MainSettingsTab\";\r\nimport {getOutputChannelsOptionList} from \"../output_channels/OutputChannelFunctions\";\r\nimport {\r\n    OutputChannelCode,\r\n    OutputChannelOrder,\r\n    OutputHandlingMode,\r\n    OutputStream,\r\n} from \"../output_channels/OutputChannelCode\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {CommandPaletteOptions, ICommandPaletteOptions, PlatformId, PlatformNames} from \"./SC_MainSettings\";\r\nimport {createShellSelectionField} from \"./setting_elements/CreateShellSelectionField\";\r\nimport {\r\n    generateIgnoredErrorCodesIconTitle,\r\n    generateShellCommandFieldIconAndName\r\n} from \"./setting_elements/CreateShellCommandField\";\r\nimport {createPlatformSpecificShellCommandField} from \"./setting_elements/CreatePlatformSpecificShellCommandField\";\r\nimport {createTabs, TabStructure} from \"./setting_elements/Tabs\";\r\nimport {createAutocomplete} from \"./setting_elements/Autocomplete\";\r\nimport {getSC_Events} from \"../events/SC_EventList\";\r\nimport {SC_Event} from \"../events/SC_Event\";\r\nimport {\r\n    copyToClipboard,\r\n    gotoURL,\r\n} from \"../Common\";\r\nimport {SC_Modal} from \"../SC_Modal\";\r\nimport {\r\n    getDefaultPreaction_Prompt_Configuration,\r\n    getModel,\r\n    Preaction_Prompt_Configuration,\r\n    Prompt,\r\n    PromptModel,\r\n    PromptSettingsModal,\r\n} from \"../imports\";\r\nimport {CmdOrCtrl} from \"../Hotkeys\";\r\nimport {\r\n    getIconHTML,\r\n    ICON_LIST_SORTED_UNIQUE,\r\n} from \"../Icons\";\r\nimport {OutputWrapper} from \"../models/output_wrapper/OutputWrapper\";\r\nimport {OutputWrapperModel} from \"../models/output_wrapper/OutputWrapperModel\";\r\nimport {OutputWrapperSettingsModal} from \"../models/output_wrapper/OutputWrapperSettingsModal\";\r\nimport {\r\n    DocumentationOutputHandlingModeLink,\r\n    DocumentationStdinContentLink,\r\n} from \"../Documentation\";\r\nimport {decorateMultilineField} from \"./setting_elements/multilineField\";\r\nimport {createVariableDefaultValueFields} from \"./setting_elements/createVariableDefaultValueFields\";\r\n\r\n/**\r\n * TODO: Rename to ShellCommandSettingsModal\r\n */\r\nexport class ExtraOptionsModal extends SC_Modal {\r\n    public static GENERAL_OPTIONS_SUMMARY = \"Alias, Icon, Confirmation, Stdin\";\r\n    public static PREACTIONS_OPTIONS_SUMMARY = \"Preactions: Prompt for asking values from user\";\r\n    public static OUTPUT_OPTIONS_SUMMARY = \"Stdout/stderr handling, Ignore errors\";\r\n    public static ENVIRONMENTS_OPTIONS_SUMMARY = \"Shell selection, Operating system specific shell commands\";\r\n    public static EVENTS_SUMMARY = \"Events\";\r\n    public static VARIABLES_SUMMARY = \"Default values for variables\";\r\n\r\n    private readonly shell_command_id: string;\r\n    private readonly t_shell_command: TShellCommand;\r\n    private name_setting: Setting;\r\n    private setting_tab: SC_MainSettingsTab;\r\n    private tab_structure: TabStructure;\r\n\r\n    constructor(plugin: SC_Plugin, shell_command_id: string, setting_tab: SC_MainSettingsTab) {\r\n        super(plugin);\r\n        this.shell_command_id = shell_command_id;\r\n        this.t_shell_command = plugin.getTShellCommands()[shell_command_id];\r\n        this.name_setting = setting_tab.setting_groups[shell_command_id].name_setting;\r\n        this.setting_tab = setting_tab;\r\n    }\r\n\r\n    public onOpen() {\r\n        super.onOpen();\r\n\r\n        this.modalEl.createEl(\"h2\", {text: this.t_shell_command.getDefaultShellCommand()});  // TODO: Use this.setTitle() instead.\r\n\r\n        // Tabs\r\n        this.tab_structure = createTabs(this.modalEl, {\r\n            \"extra-options-general\": {\r\n                title: \"General\",\r\n                icon: \"gear\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabGeneral(container_element);\r\n                },\r\n            },\r\n            \"extra-options-preactions\": {\r\n                title: \"Preactions\",\r\n                icon: \"note-glyph\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabPreactions(container_element);\r\n                },\r\n            },\r\n            \"extra-options-output\": {\r\n                title: \"Output\",\r\n                icon: \"lines-of-text\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabOutput(container_element);\r\n                },\r\n            },\r\n            \"extra-options-environments\": {\r\n                title: \"Environments\",\r\n                icon: \"stacked-levels\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabEnvironments(container_element);\r\n                },\r\n            },\r\n            \"extra-options-events\": {\r\n                title: \"Events\",\r\n                icon: \"dice\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabEvents(container_element);\r\n                },\r\n            },\r\n            \"extra-options-variables\": {\r\n                title: \"Variables\",\r\n                icon: \"code-glyph\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabVariables(container_element);\r\n                },\r\n            },\r\n        });\r\n\r\n        // Hotkeys for moving to next/previous shell command\r\n        const switch_to_t_shell_command = (t_shell_command: TShellCommand) => {\r\n            const new_modal = new ExtraOptionsModal(this.plugin, t_shell_command.getId(), this.setting_tab);\r\n            this.close(); // Needs to be closed before the new one is opened, otherwise the new one's tab content won't be shown.\r\n            new_modal.open();\r\n            new_modal.activateTab(this.tab_structure.active_tab_id);\r\n        };\r\n        this.scope.register([\"Mod\"], \"ArrowUp\", () => {\r\n            const previousTShellCommand = this.t_shell_command.previousTShellCommand();\r\n            if (previousTShellCommand) {\r\n                switch_to_t_shell_command(previousTShellCommand);\r\n            }\r\n        });\r\n        this.scope.register([\"Mod\"], \"ArrowDown\", () => {\r\n            const nextTShellCommand = this.t_shell_command.nextTShellCommand();\r\n            if (nextTShellCommand) {\r\n                switch_to_t_shell_command(nextTShellCommand);\r\n            }\r\n        });\r\n        new Setting(this.modalEl)\r\n            .setDesc(\"Tip! Hit \" + CmdOrCtrl() + \" + up/down to switch to previous/next shell command.\")\r\n        ;\r\n    }\r\n\r\n    private tabGeneral(container_element: HTMLElement) {\r\n        // Alias field\r\n        const alias_container = container_element.createDiv({attr: {class: \"SC-setting-group\"}});\r\n        new Setting(alias_container)\r\n            .setName(\"Alias\")\r\n        ;\r\n        const on_alias_change = async (value: string) => {\r\n            // Change the actual alias value\r\n            this.t_shell_command.getConfiguration().alias = value;\r\n\r\n            // Update Obsidian command palette\r\n            this.t_shell_command.renameObsidianCommand(this.t_shell_command.getShellCommand(), this.t_shell_command.getAlias());\r\n\r\n            // UpdateShell commands settings panel\r\n            this.name_setting.nameEl.innerHTML = generateShellCommandFieldIconAndName(this.t_shell_command);\r\n\r\n            // Save\r\n            await this.plugin.saveSettings();\r\n        };\r\n        const alias_setting = new Setting(alias_container)\r\n            .addText(text => text\r\n                .setValue(this.t_shell_command.getAlias())\r\n                .onChange(on_alias_change)\r\n            )\r\n            .setClass(\"SC-no-description\")\r\n        ;\r\n        const alias_input_element: HTMLInputElement = alias_setting.controlEl.find(\"input\") as HTMLInputElement;\r\n        alias_input_element.addClass(\"SC-focus-element-on-tab-opening\"); // Focus without a need to click the field.\r\n        if (this.plugin.settings.show_autocomplete_menu) {\r\n            // Show autocomplete menu (= a list of available variables).\r\n            createAutocomplete(this.plugin, alias_input_element, on_alias_change);\r\n        }\r\n\r\n        alias_container.createEl(\"p\", {text: \"If not empty, the alias will be displayed in the command palette instead of the actual command. An alias is never executed as a command.\"});\r\n        alias_container.createEl(\"p\", {text: \"You can also use the same {{}} style variables in aliases that are used in shell commands. When variables are used in aliases, they do not affect the command execution in any way, but it's a nice way to reveal what values your command will use, even when an alias hides most of the other technical details. Starting a variable with {{! will prevent escaping special characters in command palette.\"});\r\n\r\n        // Icon field\r\n        const current_icon = this.t_shell_command.getConfiguration().icon;\r\n        const icon_setting = new Setting(container_element)\r\n            .setDesc(\"If defined, the icon will be shown in file menu, folder menu, and editor menu in front of the alias text. It's also shown in the settings. It makes it easier to distinguish different shell commands visually from each other.\")\r\n            .addDropdown(dropdown => dropdown\r\n                .addOption(\"no-icon\", \"No icon\") // Need to use a non-empty string like \"no-icon\", because if 'value' would be \"\" then it becomes the same as 'display' from some reason, i.e. \"No icon\".\r\n                .then((dropdown) => {\r\n                    // Iterate all available icons.\r\n                    for (const icon_id of ICON_LIST_SORTED_UNIQUE) {\r\n                        // Create an option for the icon.\r\n                        dropdown.addOption(icon_id, icon_id);\r\n                    }\r\n                    dropdown.setValue(current_icon ?? \"\"); // \"\" == the 'No icon' option.\r\n                })\r\n                .onChange(async (new_icon) => {\r\n                    if (\"no-icon\" === new_icon) {\r\n                        // Disable icon\r\n                        this.t_shell_command.getConfiguration().icon = null;\r\n\r\n                        // Remove the icon from the modal\r\n                        icon_setting.nameEl.innerHTML = \"Icon\";\r\n                    } else {\r\n                        // Set or change the icon\r\n                        this.t_shell_command.getConfiguration().icon = new_icon;\r\n\r\n                        // Update the icon in the modal\r\n                        icon_setting.nameEl.innerHTML = \"Icon \" + getIconHTML(new_icon);\r\n                    }\r\n\r\n                    // Update (or remove) the icon in the main settings panel\r\n                    this.name_setting.nameEl.innerHTML = generateShellCommandFieldIconAndName(this.t_shell_command);\r\n\r\n                    // Save settings\r\n                    await this.plugin.saveSettings();\r\n                }),\r\n            )\r\n        ;\r\n        icon_setting.nameEl.innerHTML = \"Icon \" + (current_icon ? getIconHTML(current_icon) : \"\");\r\n\r\n        // Confirm execution field\r\n        new Setting(container_element)\r\n            .setName(\"Ask confirmation before execution\")\r\n            .addToggle(toggle => toggle\r\n                .setValue(this.t_shell_command.getConfirmExecution())\r\n                .onChange(async (value) => {\r\n                    this.t_shell_command.getConfiguration().confirm_execution = value;\r\n                    const icon_container = this.name_setting.nameEl.find(\"span.shell-commands-confirm-execution-icon-container\");\r\n                    if (this.t_shell_command.getConfirmExecution()) {\r\n                        // Show icon\r\n                        icon_container.removeClass(\"SC-hide\");\r\n                    } else {\r\n                        // Hide icon\r\n                        icon_container.addClass(\"SC-hide\");\r\n                    }\r\n                    await this.plugin.saveSettings();\r\n                })\r\n            )\r\n        ;\r\n\r\n        // Stdin field\r\n        new Setting(container_element)\r\n            .setName(\"Pass variables to standard input (stdin) (experimental)\")\r\n            .setDesc(\"Used to pass long texts as input to the shell command. There is a limit to command line length, and e.g. {{note_content}} might provide a value too long to be used as an argument, so it works better when passed to stdin. Also, programs that ask multiple values interactively, can be fed with values using stdin. If there are multiple values that need to be inputted, put them on separate lines. Many shell programs interpret newlines as separators between different values.\")\r\n            .addExtraButton(extraButtonComponent => extraButtonComponent\r\n                .setIcon(\"help\")\r\n                .setTooltip(\"Documentation: Pass variables to stdin\")\r\n                .onClick(() => gotoURL(DocumentationStdinContentLink))\r\n            )\r\n        ;\r\n        const stdinSettingContainer = container_element.createDiv({attr: {class: \"SC-setting-group\"}});\r\n        const onStdinChange = async (newStdinContent: string) => {\r\n            if (\"\" === newStdinContent) {\r\n                // Set to null\r\n                this.t_shell_command.getConfiguration().input_contents.stdin = null;\r\n            } else {\r\n                // Set value\r\n                this.t_shell_command.getConfiguration().input_contents.stdin = newStdinContent;\r\n            }\r\n            await this.plugin.saveSettings();\r\n        };\r\n        new Setting(stdinSettingContainer)\r\n            .setDesc(\"Can contain {{variables}} and/or static text.\")\r\n            .addTextArea(textareaComponent => {\r\n                textareaComponent\r\n                    .setValue(this.t_shell_command.getInputChannels().stdin ?? \"\")\r\n                ;\r\n                decorateMultilineField(this.plugin, textareaComponent, onStdinChange);\r\n                if (this.plugin.settings.show_autocomplete_menu) {\r\n                    // Show autocomplete menu (= a list of available variables).\r\n                    createAutocomplete(this.plugin, textareaComponent.inputEl, onStdinChange);\r\n                }\r\n            })\r\n        ;\r\n\r\n        // Shell command id\r\n        new Setting(container_element)\r\n            .setDesc(`Shell command id: ${this.shell_command_id}`)\r\n            .addExtraButton(button => button\r\n                .setIcon(\"documents\")\r\n                .setTooltip(`Copy ${this.shell_command_id} to the clipboard.`)\r\n                .onClick(() => {\r\n                    copyToClipboard(this.shell_command_id);\r\n                    this.plugin.newNotification(`${this.shell_command_id} was copied to the clipboard.`);\r\n                }),\r\n            )\r\n        ;\r\n        if (this.t_shell_command.canAddToCommandPalette()) {\r\n            // Only show Obsidian command palette id if the shell command is available in the command palette.\r\n            const obsidian_command_id = this.t_shell_command.getObsidianCommand().id;\r\n            new Setting(container_element)\r\n                .setDesc(`Obsidian command palette id: ${obsidian_command_id}`)\r\n                .addExtraButton(button => button\r\n                    .setIcon(\"documents\")\r\n                    .setTooltip(`Copy ${obsidian_command_id} to the clipboard.`)\r\n                    .onClick(() => {\r\n                        copyToClipboard(obsidian_command_id);\r\n                        this.plugin.newNotification(`${obsidian_command_id} was copied to the clipboard.`);\r\n                    }),\r\n                )\r\n                .settingEl.addClass(\"SC-no-top-border\") // No horizontal ruler between the two id elements.\r\n            ;\r\n        }\r\n    }\r\n\r\n    private tabPreactions(container_element: HTMLElement) {\r\n        container_element.createEl(\"p\", {text: \"Preactions are performed before the actual shell command gets executed, to do certain preparations for the shell command.\"});\r\n        const preactions_configuration = this.t_shell_command.getConfiguration().preactions;\r\n\r\n        // Load config values\r\n        let preaction_prompt_configuration: Preaction_Prompt_Configuration | null = null;\r\n        for (const preaction_configuration of preactions_configuration) {\r\n            switch (preaction_configuration.type) {\r\n                case \"prompt\":\r\n                    preaction_prompt_configuration = preaction_configuration as Preaction_Prompt_Configuration;\r\n                    break;\r\n                default:\r\n                    throw new Error(\"Unrecognised preaction type: \" + preaction_configuration.type);\r\n            }\r\n        }\r\n\r\n        // Preaction: Prompt\r\n        const prompt_options: {[key: string]: string} = {};\r\n        this.plugin.getPrompts().forEach((prompt: Prompt) => {\r\n            prompt_options[prompt.getID()] = prompt.getTitle();\r\n        });\r\n        let old_selected_prompt_option: string = (preaction_prompt_configuration?.enabled) ? preaction_prompt_configuration.prompt_id as string : \"no-prompt\";\r\n        new Setting(container_element)\r\n            .setName(\"Prompt\")\r\n            .setDesc(\"Prompts are used to ask values from the user right before shell command execution. The values can be accessed in the shell command via custom variables. You can manage all prompts in the plugin's main settings view, under the 'Preactions' tab.\")\r\n            .addDropdown(dropdown => dropdown\r\n                .addOption(\"no-prompt\", \"No prompt\")\r\n                .addOptions(prompt_options)\r\n                .addOption(\"new\", \"Create a new prompt\")\r\n                .setValue(old_selected_prompt_option)\r\n                .onChange(async (new_prompt_id: string) => {\r\n                    // Create a PreactionPromptConfiguration if it does not exist.\r\n                    if (!preaction_prompt_configuration) {\r\n                        preaction_prompt_configuration = getDefaultPreaction_Prompt_Configuration();\r\n                        preactions_configuration.push(preaction_prompt_configuration);\r\n                        this.t_shell_command.resetPreactions();\r\n                    }\r\n\r\n                    // Interpret the selection\r\n                    switch (new_prompt_id) {\r\n                        case \"new\": {\r\n                            // Create a new Prompt.\r\n                            const model = getModel<PromptModel>(PromptModel.name);\r\n                            const new_prompt = model.newInstance(this.plugin.settings);\r\n                            this.plugin.saveSettings().then(() => {\r\n                                const modal = new PromptSettingsModal(\r\n                                    this.plugin,\r\n                                    new_prompt,\r\n                                    undefined,\r\n                                    \"Create prompt\",\r\n                                    async () => {\r\n                                        // Prompt is created.\r\n                                        dropdown.addOption(new_prompt.getID(), new_prompt.getTitle());\r\n                                        dropdown.setValue(new_prompt.getID());\r\n                                        (preaction_prompt_configuration as Preaction_Prompt_Configuration).enabled = true; // 'as Preaction_Prompt_Configuration' tells TypeScript that the variable is not null.\r\n                                        (preaction_prompt_configuration as Preaction_Prompt_Configuration).prompt_id = new_prompt.getID();\r\n                                        await this.plugin.saveSettings();\r\n                                        old_selected_prompt_option = dropdown.getValue();\r\n                                    },\r\n                                    async () => {\r\n                                        // Prompt creation was cancelled.\r\n                                        dropdown.setValue(old_selected_prompt_option); // Reset the dropdown selection.\r\n                                        model.deleteInstance(new_prompt);\r\n                                        await this.plugin.saveSettings();\r\n                                    },\r\n                                );\r\n                                modal.open();\r\n                            });\r\n                            break;\r\n                        } case \"no-prompt\": {\r\n                            // Disable the prompt.\r\n                            preaction_prompt_configuration.enabled = false;\r\n                            this.t_shell_command.resetPreactions();\r\n                            await this.plugin.saveSettings();\r\n                            old_selected_prompt_option = dropdown.getValue();\r\n                            break;\r\n                        } default: {\r\n                            // Use an existing prompt.\r\n                            preaction_prompt_configuration.enabled = true;\r\n                            preaction_prompt_configuration.prompt_id = new_prompt_id;\r\n                            await this.plugin.saveSettings();\r\n                            old_selected_prompt_option = dropdown.getValue();\r\n                            break;\r\n                        }\r\n                    }\r\n                }),\r\n            )\r\n        ;\r\n    }\r\n\r\n    private tabOutput(container_element: HTMLElement) {\r\n        // Output channeling\r\n        const stdout_channel_setting = this.newOutputChannelSetting(container_element, \"Output channel for stdout\", \"stdout\");\r\n        this.newOutputChannelSetting(container_element, \"Output channel for stderr\", \"stderr\", \"If both stdout and stderr use the same channel, stderr will be combined to same message with stdout.\");\r\n\r\n        // Output wrappers\r\n        this.newOutputWrapperSetting(container_element, \"Output wrapper for stdout\", \"stdout\", \"Output wrappers can be used to surround output with predefined text, e.g. to put output into a code block. Note: If 'Output mode' is 'Realtime', wrappers will probably appear multiple times in output!\");\r\n        this.newOutputWrapperSetting(container_element, \"Output wrapper for stderr\", \"stderr\");\r\n\r\n        // Output handling mode\r\n        new Setting(container_element)\r\n            .setName(\"Output handling mode\")\r\n            .setDesc(\"Set to 'Realtime' if your shell command runs for a long time AND you want output handling to start as soon as any outputted content is available. Output channels might be used multiple times during a single process. 'Wait until finished' postpones output handling until all output is received, and handles it as a single bunch. If uncertain, use the traditional 'Wait until finished'.\")\r\n            .addDropdown(dropdown => dropdown\r\n                .addOptions({\r\n                    \"buffered\": \"Wait until finished\",\r\n                    \"realtime\": \"Realtime (experimental)\",\r\n                })\r\n                .setValue(this.t_shell_command.getConfiguration().output_handling_mode)\r\n                .onChange(async (newMode: string) => {\r\n                    this.t_shell_command.getConfiguration().output_handling_mode = newMode as OutputHandlingMode;\r\n                    await this.plugin.saveSettings();\r\n                }),\r\n            )\r\n\r\n            // Documentation link\r\n            .addExtraButton(icon => icon\r\n                .setIcon(\"help\")\r\n                .onClick(() => gotoURL(DocumentationOutputHandlingModeLink))\r\n                .setTooltip(\"Documentation: Output handling mode\"),\r\n            )\r\n        ;\r\n\r\n        // Order of output channels\r\n        new Setting(container_element)\r\n            .setName(\"Order of stdout/stderr output\")\r\n            .setDesc(\"When output contains both errors and normal output, which one should be presented first? (Only matters if 'Output handling' is 'Wait until finished').\")\r\n            .addDropdown(dropdown => dropdown\r\n                .addOptions({\r\n                    \"stdout-first\": \"Stdout first, then stderr.\",\r\n                    \"stderr-first\": \"Stderr first, then stdout.\",\r\n                })\r\n                .setValue(this.t_shell_command.getOutputChannelOrder())\r\n                .onChange(async (value: OutputChannelOrder) => {\r\n                    this.t_shell_command.getConfiguration().output_channel_order = value;\r\n                    await this.plugin.saveSettings();\r\n                })\r\n            )\r\n        ;\r\n\r\n        // Focus on the stdout channel dropdown field\r\n        stdout_channel_setting.controlEl.find(\"select\").addClass(\"SC-focus-element-on-tab-opening\");\r\n\r\n        // Ignore errors field\r\n        new Setting(container_element)\r\n            .setName(\"Ignore error codes\")\r\n            .setDesc(\"A comma separated list of numbers. If executing a shell command fails with one of these exit codes, no error message will be displayed, and the above stderr channel will be ignored. Stdout channel will still be used for stdout. Error codes must be integers and greater than or equal to 0. Anything else will be removed. Note: If 'Output handling' is 'Realtime', no exit code based ignoring can be done, as an error code is only received when a shell command process finishes.\")\r\n            .addText(text => text\r\n                .setValue(this.t_shell_command.getIgnoreErrorCodes().join(\",\"))\r\n                .onChange(async (value) => {\r\n                    // Parse the string of comma separated numbers\r\n                    const ignore_error_codes: number[] = [];\r\n                    const raw_error_codes = value.split(\",\");\r\n                    for (const i in raw_error_codes) {\r\n                        const raw_error_code = raw_error_codes[i];\r\n                        const error_code_candidate = parseInt(raw_error_code.trim()); // E.g. an empty string converts to NaN (= Not a Number).\r\n                        // Ensure that the error code is not NaN, 0 or a negative number.\r\n                        if (!isNaN(error_code_candidate) && error_code_candidate >= 0) {\r\n                            // The candidate is legit.\r\n                            ignore_error_codes.push(error_code_candidate);\r\n                        }\r\n                    }\r\n\r\n                    // Save the validated error numbers\r\n                    this.t_shell_command.getConfiguration().ignore_error_codes = ignore_error_codes;\r\n                    await this.plugin.saveSettings();\r\n\r\n                    // Update icon\r\n                    const icon_container = this.name_setting.nameEl.find(\"span.shell-commands-ignored-error-codes-icon-container\");\r\n                    if (this.t_shell_command.getIgnoreErrorCodes().length) {\r\n                        // Show icon\r\n                        icon_container.setAttr(\"aria-label\", generateIgnoredErrorCodesIconTitle(this.t_shell_command.getIgnoreErrorCodes()));\r\n                        icon_container.removeClass(\"SC-hide\");\r\n                    } else {\r\n                        // Hide icon\r\n                        icon_container.addClass(\"SC-hide\");\r\n                    }\r\n                })\r\n            )\r\n        ;\r\n    }\r\n\r\n    private tabEnvironments(container_element: HTMLElement) {\r\n        // Platform specific shell commands\r\n        let platform_id: PlatformId;\r\n        let is_first = true;\r\n        for (platform_id in PlatformNames) {\r\n            const setting_group = createPlatformSpecificShellCommandField(this.plugin, container_element, this.t_shell_command, platform_id, this.plugin.settings.show_autocomplete_menu);\r\n            if (is_first) {\r\n                // Focus on the first OS specific shell command field\r\n                setting_group.shell_command_setting.controlEl.find(\"textarea\").addClass(\"SC-focus-element-on-tab-opening\");\r\n                is_first = false;\r\n            }\r\n        }\r\n\r\n        // Platform specific shell selection\r\n        createShellSelectionField(this.plugin, container_element, this.t_shell_command.getShells(), false);\r\n    }\r\n\r\n    private tabEvents(container_element: HTMLElement) {\r\n        // Command palette\r\n        const command_palette_availability_setting = new Setting(container_element)\r\n            .setName(\"Availability in Obsidian's command palette\")\r\n            .addDropdown(dropdown => dropdown\r\n                .addOptions(CommandPaletteOptions)\r\n                .setValue(this.t_shell_command.getConfiguration().command_palette_availability)\r\n                .onChange(async (value: keyof ICommandPaletteOptions) => {\r\n\r\n                    // Store value\r\n                    this.t_shell_command.getConfiguration().command_palette_availability = value;\r\n\r\n                    // Update command palette\r\n                    if (this.t_shell_command.canAddToCommandPalette()) {\r\n                        // Register to command palette\r\n                        this.t_shell_command.registerToCommandPalette();\r\n                    } else {\r\n                        // Unregister from command palette\r\n                        this.t_shell_command.unregisterFromCommandPalette();\r\n                    }\r\n\r\n                    // Save\r\n                    await this.plugin.saveSettings();\r\n                }),\r\n            )\r\n        ;\r\n\r\n        // Focus on the command palette availability field\r\n        command_palette_availability_setting.controlEl.find(\"select\").addClass(\"SC-focus-element-on-tab-opening\");\r\n\r\n        // Events\r\n        new Setting(container_element)\r\n            .setName(\"Execute this shell command automatically when:\")\r\n            .setHeading() // Make the name bold\r\n        ;\r\n        getSC_Events(this.plugin).forEach((sc_event: SC_Event) => {\r\n            const is_event_enabled: boolean = this.t_shell_command.isSC_EventEnabled(sc_event.static().getCode());\r\n            const setting = new Setting(container_element)\r\n                .setName(sc_event.static().getTitle())\r\n                .addToggle(toggle => toggle\r\n                    .setValue(is_event_enabled)\r\n                    .onChange(async (enable: boolean) => {\r\n                        if (enable) {\r\n                            // Enable the event\r\n                            this.t_shell_command.enableSC_Event(sc_event);\r\n                            extra_settings_container.style.display = \"block\"; // Show extra settings\r\n                        } else {\r\n                            // Disable the event\r\n                            this.t_shell_command.disableSC_Event(sc_event);\r\n                            extra_settings_container.style.display = \"none\"; // Hide extra settings\r\n                        }\r\n                        // Save\r\n                        await this.plugin.saveSettings();\r\n                    }),\r\n                )\r\n\r\n                // Documentation icon\r\n                .addExtraButton(icon => icon\r\n                    .setIcon(\"help\")\r\n                    .onClick(() => gotoURL(sc_event.static().getDocumentationLink()))\r\n                    .setTooltip(\"Documentation: \" + sc_event.static().getTitle() + \" event\"),\r\n                )\r\n            ;\r\n\r\n            // Mention additional variables (if any)\r\n            if (sc_event.createSummaryOfEventVariables(setting.descEl)) {\r\n                setting.descEl.insertAdjacentText(\"afterbegin\", \"Additional variables: \");\r\n            }\r\n\r\n            // Extra settings\r\n            const extra_settings_container = container_element.createDiv();\r\n            extra_settings_container.style.display = is_event_enabled ? \"block\" : \"none\";\r\n            sc_event.createExtraSettingsFields(extra_settings_container, this.t_shell_command);\r\n        });\r\n    }\r\n\r\n    private tabVariables(containerElement: HTMLElement) {\r\n\r\n        // Default values for variables\r\n        new Setting(containerElement)\r\n            .setName(\"Default values for variables\")\r\n            .setDesc(\"Certain variables can be inaccessible during certain situations, e.g. {{file_name}} is not available when no file pane is focused. You can define default values that will be used when a variable is otherwise unavailable.\")\r\n            .setHeading()\r\n        ;\r\n\r\n        createVariableDefaultValueFields(\r\n            this.plugin,\r\n            containerElement,\r\n            this.t_shell_command,\r\n        );\r\n    }\r\n\r\n    public activateTab(tab_id: string) {\r\n        if (undefined === this.tab_structure.buttons[tab_id]) {\r\n            throw Error(\"Invalid tab id: \" + tab_id);\r\n        }\r\n        this.tab_structure.buttons[tab_id].click();\r\n    }\r\n\r\n    private newOutputChannelSetting(container_element: HTMLElement, title: string, output_stream_name: OutputStream, description = \"\") {\r\n        const output_channel_options = getOutputChannelsOptionList(output_stream_name);\r\n        return new Setting(container_element)\r\n            .setName(title)\r\n            .setDesc(description)\r\n            .addDropdown(dropdown => dropdown\r\n                .addOptions(output_channel_options)\r\n                .setValue(this.t_shell_command.getOutputChannels()[output_stream_name])\r\n                .onChange(async (value: OutputChannelCode) => {\r\n                    this.t_shell_command.getConfiguration().output_channels[output_stream_name] = value;\r\n                    await this.plugin.saveSettings();\r\n                })\r\n            )\r\n        ;\r\n    }\r\n\r\n    private newOutputWrapperSetting(container_element: HTMLElement, title: string, output_stream_name: OutputStream, description = \"\") {\r\n        const output_wrapper_options: {[key: string]: string} = {};\r\n        this.plugin.getOutputWrappers().forEach((output_wrapper: OutputWrapper) => {\r\n            output_wrapper_options[output_wrapper.getID()] = output_wrapper.getTitle();\r\n        });\r\n        const output_wrappers = this.t_shell_command.getConfiguration().output_wrappers;\r\n        let old_selected_output_wrapper_option: string = output_wrappers[output_stream_name] ?? \"no-output-wrapper\";\r\n        return new Setting(container_element)\r\n            .setName(title)\r\n            .setDesc(description)\r\n            .addDropdown(dropdown_component => dropdown_component\r\n                .addOption(\"no-output-wrapper\", \"No \"+output_stream_name+\" wrapper\")\r\n                .addOptions(output_wrapper_options)\r\n                .addOption(\"new\", \"Create a new output wrapper\")\r\n                .setValue(old_selected_output_wrapper_option)\r\n                .onChange(async (output_wrapper_id: string) => {\r\n                    switch (output_wrapper_id) {\r\n                        case \"new\": {\r\n                            // Create a new OutputWrapper.\r\n                            const output_wrapper_model = getModel<OutputWrapperModel>(OutputWrapperModel.name);\r\n                            const new_output_wrapper = output_wrapper_model.newInstance(this.plugin.settings);\r\n                            this.plugin.saveSettings().then(() => {\r\n                                const modal = new OutputWrapperSettingsModal(\r\n                                    this.plugin,\r\n                                    new_output_wrapper,\r\n                                    undefined,\r\n                                    \"Create output wrapper\",\r\n                                    async () => {\r\n                                        // Output wrapper is created.\r\n                                        dropdown_component.addOption(new_output_wrapper.getID(), new_output_wrapper.getTitle());\r\n                                        dropdown_component.setValue(new_output_wrapper.getID());\r\n                                        output_wrappers[output_stream_name] = new_output_wrapper.getID();\r\n                                        await this.plugin.saveSettings();\r\n                                        old_selected_output_wrapper_option = dropdown_component.getValue();\r\n                                    },\r\n                                    async () => {\r\n                                        // Prompt creation was cancelled.\r\n                                        dropdown_component.setValue(old_selected_output_wrapper_option); // Reset the dropdown selection.\r\n                                        output_wrapper_model.deleteInstance(new_output_wrapper);\r\n                                        await this.plugin.saveSettings();\r\n                                    },\r\n                                );\r\n                                modal.open();\r\n                            });\r\n                            break;\r\n                        }\r\n                        case \"no-output-wrapper\": {\r\n                            // Disable output wrapper.\r\n                            output_wrappers[output_stream_name] = null;\r\n                            await this.plugin.saveSettings();\r\n                            break;\r\n                        }\r\n                        default: {\r\n                            // Use an existing output wrapper.\r\n                            output_wrappers[output_stream_name] = output_wrapper_id;\r\n                            await this.plugin.saveSettings();\r\n                            break;\r\n                        }\r\n                    }\r\n                })\r\n            )\r\n        ;\r\n    }\r\n\r\n    protected approve(): void {\r\n        // No need to perform any action, just close the modal.\r\n        this.close();\r\n    }\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {SC_Modal} from \"../SC_Modal\";\r\nimport SC_Plugin from \"../main\";\r\nimport {SettingFieldGroup} from \"./SC_MainSettingsTab\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {debugLog} from \"../Debug\";\r\n\r\n/**\r\n * TODO: Rename to DeleteShellCommandModal\r\n */\r\nexport class DeleteModal extends SC_Modal {\r\n\r\n    private readonly shell_command_id: string;\r\n    private readonly t_shell_command: TShellCommand;\r\n    private setting_group: SettingFieldGroup;\r\n    private shell_command_element: HTMLElement;\r\n\r\n    constructor(plugin: SC_Plugin, shell_command_id: string, setting_group: SettingFieldGroup, shell_command_element: HTMLElement) {\r\n        super(plugin);\r\n        this.shell_command_id = shell_command_id;\r\n        this.t_shell_command = plugin.getTShellCommands()[shell_command_id];\r\n        this.setting_group = setting_group;\r\n        this.shell_command_element = shell_command_element;\r\n    }\r\n\r\n    public onOpen() {\r\n        super.onOpen();\r\n\r\n        this.modalEl.createEl(\"h2\", {text: \"Delete: \" + this.t_shell_command.getShellCommand()}); // TODO: Use this.setTitle() instead.\r\n        if (this.t_shell_command.getAlias()) {\r\n            this.modalEl.createEl(\"p\", {text: \"Alias: \" + this.t_shell_command.getAlias()});\r\n        }\r\n        this.modalEl.createEl(\"p\", {text: \"Are you sure you want to delete this shell command?\"});\r\n        const delete_button = this.modalEl.createEl(\"button\", {text: \"Yes, delete\"});\r\n        delete_button.onclick = async () => this.approve();\r\n    }\r\n\r\n    protected async approve() {\r\n        // Unregister possible events in order to prevent them becoming ghosts that just keep executing even after removing the configuration.\r\n        this.t_shell_command.unregisterSC_Events();\r\n\r\n        // Remove the command\r\n        debugLog(\"Command \" + this.shell_command_id + \" gonna be removed.\");\r\n        this.t_shell_command.unregisterFromCommandPalette(); // Remove from the command palette.\r\n        delete this.plugin.getTShellCommands()[this.shell_command_id]; // Remove the TShellCommand object.\r\n\r\n        // Remove from the plugin's settings.\r\n        const shellCommandIndex: number | undefined = this.plugin.getShellCommandConfigurationIndex(this.shell_command_id);\r\n        // Index probably always exists, but check just in case. Will make TypeScript compiler happy. :)\r\n        if (undefined == shellCommandIndex) {\r\n            throw new Error(\"Shell command deletion failed. Did not get shell command index in settings container.\");\r\n        }\r\n        this.plugin.settings.shell_commands.splice(shellCommandIndex,1);\r\n\r\n        // Remove the setting fields\r\n        this.shell_command_element.remove();\r\n\r\n        await this.plugin.saveSettings();\r\n        debugLog(\"Command removed.\");\r\n        this.close();\r\n    }\r\n\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {TShellCommand} from \"../../TShellCommand\";\r\nimport {Hotkey, setIcon} from \"obsidian\";\r\nimport {ExtraOptionsModal} from \"../ExtraOptionsModal\";\r\nimport {DeleteModal} from \"../DeleteModal\";\r\nimport {CmdOrCtrl, getHotkeysForShellCommand, HotkeyToString} from \"../../Hotkeys\";\r\nimport SC_Plugin from \"../../main\";\r\nimport {CreateShellCommandFieldCore} from \"./CreateShellCommandFieldCore\";\r\nimport {debugLog} from \"../../Debug\";\r\nimport {EOL} from \"os\";\r\nimport {\r\n    escapeMarkdownLinkCharacters,\r\n    copyToClipboard,\r\n} from \"../../Common\";\r\nimport {\r\n    ShellCommandExecutor\r\n} from \"../../imports\";\r\nimport {SC_MainSettingsTab} from \"../SC_MainSettingsTab\";\r\n\r\n/**\r\n *\r\n * @param plugin\r\n * @param container_element\r\n * @param setting_tab\r\n * @param shell_command_id Either a string formatted integer (\"0\", \"1\" etc) or \"new\" if it's a field for a command that does not exist yet.\r\n * @param show_autocomplete_menu\r\n */\r\nexport function createShellCommandField(plugin: SC_Plugin, container_element: HTMLElement, setting_tab: SC_MainSettingsTab, shell_command_id: string, show_autocomplete_menu: boolean) {\r\n    const is_new = \"new\" === shell_command_id;\r\n    let t_shell_command: TShellCommand;\r\n    if (is_new) {\r\n        // Create an empty command\r\n        t_shell_command = plugin.newTShellCommand();\r\n        shell_command_id = t_shell_command.getId(); // Replace \"new\" with a real id.\r\n    } else {\r\n        // Use an old shell command\r\n        t_shell_command = plugin.getTShellCommands()[shell_command_id];\r\n    }\r\n    debugLog(\"Create command field for command #\" + shell_command_id + (is_new ? \" (NEW)\" : \"\"));\r\n    let shell_command: string;\r\n    if (is_new) {\r\n        shell_command = \"\";\r\n    } else {\r\n        shell_command = t_shell_command.getDefaultShellCommand();\r\n    }\r\n\r\n    // Wrap all shell command setting elements in a single div.\r\n    const shell_command_element = container_element.createDiv();\r\n    shell_command_element.addClass(\"SC-id-\" + shell_command_id);\r\n\r\n    const setting_group = CreateShellCommandFieldCore(\r\n        plugin,\r\n        shell_command_element,\r\n        generateShellCommandFieldIconAndName(t_shell_command),\r\n        shell_command,\r\n        t_shell_command.getShell(),\r\n        t_shell_command,\r\n        show_autocomplete_menu,\r\n        async (shell_command: string) => {\r\n            if (is_new) {\r\n                debugLog(\"Creating new command \" + shell_command_id + \": \" + shell_command);\r\n            } else {\r\n                debugLog(\"Command \" + shell_command_id + \" gonna change to: \" + shell_command);\r\n            }\r\n\r\n            // Do this in both cases, when creating a new command and when changing an old one:\r\n            t_shell_command.getConfiguration().platform_specific_commands.default = shell_command;\r\n\r\n            if (is_new) {\r\n                // Create a new command\r\n                // plugin.registerShellCommand(t_shell_command); // I don't think this is needed to be done anymore\r\n                debugLog(\"Command created.\");\r\n            } else {\r\n                // Change an old command\r\n                t_shell_command.renameObsidianCommand(t_shell_command.getShellCommand(), t_shell_command.getAlias()); // Change the command's name in Obsidian's command palette and in hotkey settings.\r\n                debugLog(\"Command changed.\");\r\n            }\r\n            await plugin.saveSettings();\r\n        },\r\n    );\r\n    setting_tab.setting_groups[shell_command_id] = setting_group;\r\n\r\n    // Primary icon buttons\r\n    setting_group.name_setting\r\n        .addExtraButton(button => button\r\n            .setTooltip(\"Normal click: Execute now. \" + CmdOrCtrl() + \" + click: Execute and ask what to do with output.\")\r\n            .setIcon(\"run-command\")\r\n            .extraSettingsEl.addEventListener(\"click\", async (event: MouseEvent) => {\r\n                const ctrl_clicked = event.ctrlKey;\r\n                // Execute the shell command now (for trying it out in the settings)\r\n                const parsing_process = t_shell_command.createParsingProcess(null); // No SC_Event is available when executing shell commands manually.\r\n                if (await parsing_process.process()) {\r\n                    const executor = new ShellCommandExecutor(plugin, t_shell_command, null); // No SC_Event is available when manually executing the shell command.\r\n                    await executor.doPreactionsAndExecuteShellCommand(\r\n                        parsing_process,\r\n                        ctrl_clicked ? \"modal\" : undefined // If ctrl/cmd is pressed, override output channels with 'Ask after execution' modal. Otherwise, use undefined to indicate that the shell command's normal output channels should be used.\r\n                    );\r\n                } else {\r\n                    parsing_process.displayErrorMessages();\r\n                }\r\n            })\r\n        )\r\n        .addExtraButton(button => button\r\n            .setTooltip(ExtraOptionsModal.GENERAL_OPTIONS_SUMMARY)\r\n            .onClick(async () => {\r\n                // Open an extra options modal: General tab\r\n                const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);\r\n                modal.open();\r\n                modal.activateTab(\"extra-options-general\");\r\n            })\r\n        )\r\n        .addExtraButton(button => button\r\n            .setTooltip(ExtraOptionsModal.PREACTIONS_OPTIONS_SUMMARY)\r\n            .setIcon(\"note-glyph\")\r\n            .onClick(async () => {\r\n                // Open an extra options modal: Preactions tab\r\n                const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);\r\n                modal.open();\r\n                modal.activateTab(\"extra-options-preactions\");\r\n            })\r\n        )\r\n        .addExtraButton(button => button\r\n            .setTooltip(ExtraOptionsModal.OUTPUT_OPTIONS_SUMMARY)\r\n            .setIcon(\"lines-of-text\")\r\n            .onClick(async () => {\r\n                // Open an extra options modal: Output tab\r\n                const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);\r\n                modal.open();\r\n                modal.activateTab(\"extra-options-output\");\r\n            })\r\n        )\r\n        .addExtraButton(button => button\r\n            .setTooltip(ExtraOptionsModal.ENVIRONMENTS_OPTIONS_SUMMARY)\r\n            .setIcon(\"stacked-levels\")\r\n            .onClick(async () => {\r\n                // Open an extra options modal: Environments tab\r\n                const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);\r\n                modal.open();\r\n                modal.activateTab(\"extra-options-environments\");\r\n            })\r\n        )\r\n        .addExtraButton(button => button\r\n            .setTooltip(ExtraOptionsModal.EVENTS_SUMMARY)\r\n            .setIcon(\"dice\")\r\n            .onClick(async () => {\r\n                // Open an extra options modal: Events tab\r\n                const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);\r\n                modal.open();\r\n                modal.activateTab(\"extra-options-events\");\r\n            })\r\n        )\r\n        .addExtraButton(button => button\r\n            .setTooltip(ExtraOptionsModal.VARIABLES_SUMMARY)\r\n            .setIcon(\"code-glyph\")\r\n            .onClick(async () => {\r\n                // Open an extra options modal: Variables tab\r\n                const modal = new ExtraOptionsModal(plugin, shell_command_id, setting_tab);\r\n                modal.open();\r\n                modal.activateTab(\"extra-options-variables\");\r\n            })\r\n        )\r\n        .addExtraButton(button => button\r\n            .setTooltip(\"Delete this shell command\")\r\n            .setIcon(\"trash\")\r\n            .onClick(async () => {\r\n                // Open a delete modal\r\n                const modal = new DeleteModal(plugin, shell_command_id, setting_group, shell_command_element);\r\n                modal.open();\r\n            })\r\n        )\r\n    ;\r\n\r\n    // Informational icons (= non-clickable)\r\n    const icon_container = setting_group.name_setting.nameEl.createEl(\"span\", {attr: {class: \"SC-main-icon-container\"}});\r\n\r\n    // \"Ask confirmation\" icon.\r\n    const confirm_execution_icon_container = icon_container.createEl(\"span\", {attr: {\"aria-label\": \"Asks confirmation before execution.\", class: \"shell-commands-confirm-execution-icon-container\"}});\r\n    setIcon(confirm_execution_icon_container, \"languages\");\r\n    if (!t_shell_command.getConfirmExecution()) {\r\n        // Do not display the icon for commands that do not use confirmation.\r\n        confirm_execution_icon_container.addClass(\"SC-hide\");\r\n    }\r\n\r\n    // \"Ignored error codes\" icon\r\n    const ignored_error_codes_icon_container = icon_container.createEl(\"span\", {attr: {\"aria-label\": generateIgnoredErrorCodesIconTitle(t_shell_command.getIgnoreErrorCodes()), class: \"shell-commands-ignored-error-codes-icon-container\"}});\r\n    setIcon(ignored_error_codes_icon_container, \"strikethrough-glyph\");\r\n    if (!t_shell_command.getIgnoreErrorCodes().length) {\r\n        // Do not display the icon for commands that do not ignore any errors.\r\n        ignored_error_codes_icon_container.addClass(\"SC-hide\");\r\n    }\r\n\r\n    // Secondary icon buttons\r\n    setting_group.preview_setting.addExtraButton(button => button\r\n        .setIcon(\"link\")\r\n        .setTooltip(\"Copy this shell command's Obsidian URI to the clipboard. Visiting the URI executes the shell command. \" + CmdOrCtrl() + \" + click: Copy a markdown link.\")\r\n\r\n        // onClick() handler - use a custom one instead of ExtraButtonComponent.onClick(), because Obsidian API (at least v. 0.14.8) does not support detecting CTRL press. https://forum.obsidian.md/t/fr-settings-pass-mouseevent-to-extrabuttoncomponent-onclick/37177\r\n        .extraSettingsEl.addEventListener(\"click\", (event: MouseEvent) => {\r\n            const ctrl_clicked = event.ctrlKey;\r\n            const execution_uri = t_shell_command.getExecutionURI();\r\n            let result: string;\r\n            if (ctrl_clicked) {\r\n                // A full link is wanted.\r\n                result = `[${escapeMarkdownLinkCharacters(t_shell_command.getAlias())}](${escapeMarkdownLinkCharacters(execution_uri)})`;\r\n            } else {\r\n                // Only the URI is wanted.\r\n                result = execution_uri;\r\n            }\r\n\r\n            copyToClipboard(result);\r\n            plugin.newNotification(\"Copied to clipboard: \" + EOL + result);\r\n        }),\r\n    );\r\n\r\n    if (t_shell_command.canHaveHotkeys()) {\r\n        setting_group.preview_setting.addExtraButton(button => button\r\n            .setIcon(\"any-key\")\r\n            .setTooltip(\"Go to hotkey settings.\")\r\n            .onClick(() => {\r\n                // The most important parts of this closure function are copied 2022-04-27 from https://github.com/pjeby/hotkey-helper/blob/c8a032e4c52bd9ce08cb909cec15d1ed9d0a3439/src/plugin.js#L436-L442 (also from other lines of the same file).\r\n\r\n                // @ts-ignore This is private API access. Not good, but then again the feature is not crucial - if it breaks, it won't interrupt anything important.\r\n                plugin.app.setting?.openTabById(\"hotkeys\");\r\n\r\n                // @ts-ignore\r\n                const hotkeys_settings_tab = plugin.app.setting.settingTabs.filter(tab => tab.id === \"hotkeys\").shift();\r\n                if (hotkeys_settings_tab && hotkeys_settings_tab.searchInputEl && hotkeys_settings_tab.updateHotkeyVisibility) {\r\n                    debugLog(\"Hotkeys: Filtering by shell command \" + t_shell_command.getObsidianCommand().name);\r\n                    hotkeys_settings_tab.searchInputEl.value = t_shell_command.getObsidianCommand().name;\r\n                    hotkeys_settings_tab.updateHotkeyVisibility();\r\n                } else {\r\n                    debugLog(\"Hotkeys: Cannot do filtering due to API changes.\");\r\n                }\r\n            }),\r\n        );\r\n    }\r\n\r\n    // Add hotkey information\r\n    if (!is_new && t_shell_command.canHaveHotkeys()) {\r\n        const hotkeys = getHotkeysForShellCommand(plugin, shell_command_id);\r\n        if (hotkeys) {\r\n            let hotkeys_joined = \"\";\r\n            hotkeys.forEach((hotkey: Hotkey) => {\r\n                if (hotkeys_joined) {\r\n                    hotkeys_joined += \"<br>\";\r\n                }\r\n                hotkeys_joined += HotkeyToString(hotkey);\r\n            });\r\n            const hotkey_div = setting_group.preview_setting.controlEl.createEl(\"div\", {attr: {class: \"setting-item-description SC-hotkey-info\"}});\r\n            // Comment out the icon because it would look like a clickable button (as there are other clickable icons in the settings).\r\n            // setIcon(hotkey_div, \"any-key\", 22); // Hotkey icon\r\n            hotkey_div.insertAdjacentHTML(\"beforeend\", \" \" + hotkeys_joined);\r\n        }\r\n    }\r\n    debugLog(\"Created.\");\r\n}\r\n\r\n/**\r\n * @param t_shell_command\r\n * @public Exported because ShellCommandExtraOptionsModal uses this too.\r\n */\r\nexport function generateShellCommandFieldIconAndName(t_shell_command: TShellCommand) {\r\n    const icon_html = t_shell_command.getIconHTML() + \" \";\r\n    if (t_shell_command.getAlias()) {\r\n        return icon_html + t_shell_command.getAlias();\r\n    }\r\n    return icon_html + \"Shell command without alias\";\r\n}\r\n\r\n/**\r\n * @param ignored_error_codes\r\n * @public Exported because ShellCommandExtraOptionsModal uses this too.\r\n */\r\nexport function generateIgnoredErrorCodesIconTitle(ignored_error_codes: number[]) {\r\n    const plural = ignored_error_codes.length !== 1 ? \"s\" : \"\";\r\n    return \"Ignored error\"+plural+\": \" + ignored_error_codes.join(\",\");\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {App, PluginSettingTab, SearchComponent, Setting} from \"obsidian\";\r\nimport SC_Plugin from \"../main\";\r\nimport {getVaultAbsolutePath, gotoURL} from \"../Common\";\r\nimport {createShellSelectionField} from \"./setting_elements/CreateShellSelectionField\";\r\nimport {createShellCommandField} from \"./setting_elements/CreateShellCommandField\";\r\nimport {createTabs, TabStructure} from \"./setting_elements/Tabs\";\r\nimport {debugLog} from \"../Debug\";\r\nimport {\r\n    DocumentationAutocompleteLink,\r\n    DocumentationMainLink,\r\n    DocumentationBuiltInVariablesIndexLink,\r\n    GitHubLink,\r\n    ChangelogLink,\r\n    DocumentationCustomVariablesLink,\r\n    LicenseLink,\r\n    DocumentationOutputWrappersLink,\r\n} from \"../Documentation\";\r\nimport {getSC_Events} from \"../events/SC_EventList\";\r\nimport {SC_Event} from \"../events/SC_Event\";\r\nimport {TShellCommand} from \"../TShellCommand\";\r\nimport {\r\n    CustomVariable,\r\n    CustomVariableInstance,\r\n    CustomVariableModel,\r\n    getModel,\r\n    createPATHAugmentationFields,\r\n    Prompt,\r\n    PromptModel\r\n} from \"../imports\";\r\nimport {createNewModelInstanceButton} from \"../models/createNewModelInstanceButton\";\r\nimport {ExecutionNotificationMode} from \"./SC_MainSettings\";\r\nimport {OutputWrapperModel} from \"../models/output_wrapper/OutputWrapperModel\";\r\nimport {OutputWrapper} from \"../models/output_wrapper/OutputWrapper\";\r\nimport {createVariableDefaultValueField} from \"./setting_elements/createVariableDefaultValueFields\";\r\n\r\nexport class SC_MainSettingsTab extends PluginSettingTab {\r\n    private readonly plugin: SC_Plugin;\r\n\r\n    private tab_structure: TabStructure;\r\n\r\n    public setting_groups: SettingFieldGroupContainer = {};\r\n\r\n    constructor(app: App, plugin: SC_Plugin) {\r\n        super(app, plugin);\r\n        this.plugin = plugin;\r\n    }\r\n\r\n    public display(): void {\r\n        const {containerEl} = this;\r\n\r\n        containerEl.empty();\r\n\r\n        this.tab_structure = createTabs(containerEl, {\r\n            \"main-shell-commands\": {\r\n                title: \"Shell commands\",\r\n                icon: \"run-command\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabShellCommands(container_element);\r\n                },\r\n            },\r\n            \"main-environments\": {\r\n                title: \"Environments\",\r\n                icon: \"stacked-levels\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabEnvironments(container_element);\r\n                },\r\n            },\r\n            \"main-preactions\": {\r\n                title: \"Preactions\",\r\n                icon: \"note-glyph\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabPreactions(container_element);\r\n                },\r\n            },\r\n            \"main-output\": {\r\n                title: \"Output\",\r\n                icon: \"lines-of-text\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabOutput(container_element);\r\n                },\r\n            },\r\n            \"main-events\": {\r\n                title: \"Events\",\r\n                icon: \"dice\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabEvents(container_element);\r\n                },\r\n            },\r\n            \"main-variables\": {\r\n                title: \"Variables\",\r\n                icon: \"code-glyph\",\r\n                content_generator: (container_element: HTMLElement) => {\r\n                    this.tabVariables(container_element);\r\n                },\r\n            },\r\n        });\r\n\r\n        // Documentation link & GitHub links\r\n        containerEl.createEl(\"p\").insertAdjacentHTML(\"beforeend\",\r\n            \"<a href=\\\"\" + DocumentationMainLink + \"\\\">Documentation</a> - \" +\r\n            \"<a href=\\\"\" + GitHubLink + \"\\\">SC on GitHub</a> - \" +\r\n            \"<a href=\\\"\" + ChangelogLink + \"\\\">SC version: \" + this.plugin.getPluginVersion() + \"</a>\",\r\n        );\r\n\r\n        // Copyright notice\r\n        const copyright_paragraph = containerEl.createEl(\"p\");\r\n        copyright_paragraph.addClass(\"SC-small-font\");\r\n        copyright_paragraph.insertAdjacentHTML(\"beforeend\", `\r\n            <em>Shell commands</em> plugin Copyright &copy; 2021 - 2023 Jarkko Linnanvirta. This program comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome to redistribute it under certain conditions. See more information in the license: <a href=\"${LicenseLink}\">GNU GPL-3.0</a>.\r\n        `);\r\n\r\n        // KEEP THIS AFTER CREATING ALL ELEMENTS:\r\n        this.rememberLastPosition(containerEl);\r\n    }\r\n\r\n    private tabShellCommands(container_element: HTMLElement) {\r\n        // Show a search field\r\n        this.createSearchField(container_element);\r\n\r\n        // A <div> element for all command input fields. New command fields can be created at the bottom of this element.\r\n        const command_fields_container = container_element.createEl(\"div\");\r\n\r\n        // Fields for modifying existing commands\r\n        let shell_commands_exist = false;\r\n        for (const command_id in this.plugin.getTShellCommands()) {\r\n            createShellCommandField(this.plugin, command_fields_container, this, command_id, this.plugin.settings.show_autocomplete_menu);\r\n            shell_commands_exist = true;\r\n        }\r\n\r\n        // 'No shell commands yet' paragraph.\r\n        const no_shell_commands_paragraph = container_element.createEl(\"p\", {text: \"No shell commands yet, click the 'New shell command' button below.\"});\r\n        if (shell_commands_exist) {\r\n            // Shell commands exist, so do not show the \"No shell commands yet\" text.\r\n            no_shell_commands_paragraph.hide();\r\n        }\r\n\r\n        // \"New command\" button\r\n        new Setting(container_element)\r\n            .addButton(button => button\r\n                .setButtonText(\"New shell command\")\r\n                .onClick(async () => {\r\n                    createShellCommandField(this.plugin, command_fields_container, this, \"new\", this.plugin.settings.show_autocomplete_menu);\r\n                    no_shell_commands_paragraph.hide();\r\n                    debugLog(\"New empty command created.\");\r\n                })\r\n            )\r\n        ;\r\n    }\r\n\r\n    private createSearchField(container_element: HTMLElement) {\r\n        const search_container = container_element.createDiv();\r\n        const search_title = \"Search shell commands\";\r\n        const search_setting = new Setting(search_container)\r\n            .setName(search_title)\r\n            .setDesc(\"Looks up shell commands' aliases, commands, ids and icons.\")\r\n            .addSearch(search_component => search_component\r\n                .onChange((search_term: string) => {\r\n                    let count_matches = 0;\r\n                    for (const shell_command_id in this.plugin.getTShellCommands()) {\r\n                        let matched = false;\r\n                        // Check if a search term was defined.\r\n                        if (\"\" == search_term) {\r\n                            // Show all shell commands.\r\n                            matched = true;\r\n                        } else {\r\n                            // A search term is defined.\r\n                            // Define fields where to look for the search term\r\n                            const t_shell_command = this.plugin.getTShellCommands()[shell_command_id];\r\n                            const search_targets: string[] = [\r\n                                t_shell_command.getId(),\r\n                                t_shell_command.getConfiguration().alias,\r\n                            ];\r\n                            search_targets.push(...Object.values(t_shell_command.getPlatformSpecificShellCommands()));\r\n                            // Only include icon in the search if it's defined.\r\n                            const icon: string | null = t_shell_command.getConfiguration().icon;\r\n                            if (icon) {\r\n                                search_targets.push(icon);\r\n                            }\r\n\r\n                            // Check if it's a match\r\n                            search_targets.forEach((search_target: string) => {\r\n                                if (search_target.toLocaleLowerCase().contains(search_term.toLocaleLowerCase())) {\r\n                                    matched = true;\r\n                                    debugLog(\"Search \" + search_term + \" MATCHED \" + search_target);\r\n                                }\r\n                            });\r\n                        }\r\n\r\n                        // Show or hide the shell command.\r\n                        const shell_command_element = document.querySelector(\"div.SC-id-\" + shell_command_id);\r\n                        if (!shell_command_element) {\r\n                            throw new Error(\"Shell command setting element does not exist with selector div.SC-id-\" + shell_command_id);\r\n                        }\r\n                        if (matched) {\r\n                            shell_command_element.removeClass(\"SC-hide\");\r\n                            count_matches++;\r\n                        } else {\r\n                            shell_command_element.addClass(\"SC-hide\");\r\n                        }\r\n                    }\r\n\r\n                    // Display match count\r\n                    if (\"\" == search_term) {\r\n                        // Don't show match count.\r\n                        search_setting.setName(search_title);\r\n                    } else {\r\n                        // Show match count.\r\n                        switch (count_matches) {\r\n                            case 0: {\r\n                                search_setting.setName(\"No matches\");\r\n                                break;\r\n                            }\r\n                            case 1: {\r\n                                search_setting.setName(\"1 match\");\r\n                                break;\r\n                            }\r\n                            default: {\r\n                                search_setting.setName(count_matches + \" matches\");\r\n                                break;\r\n                            }\r\n                        }\r\n                    }\r\n                }).then((search_component: SearchComponent) => {\r\n                    // Focus on the search field.\r\n                    search_component.inputEl.addClass(\"SC-focus-element-on-tab-opening\");\r\n                }),\r\n            )\r\n        ;\r\n    }\r\n\r\n    private tabEvents(container_element: HTMLElement) {\r\n\r\n        // A general description about events\r\n        container_element.createEl(\"p\", {text: \"Events introduce a way to execute shell commands automatically in certain situations, e.g. when Obsidian starts. They are set up for each shell command separately, but this tab contains general options for them.\"});\r\n\r\n        // Enable/disable all events\r\n        new Setting(container_element)\r\n            .setName(\"Enable events\")\r\n            .setDesc(\"This is a quick way to immediately turn off all events, if you want.\")\r\n            .addToggle(toggle => toggle\r\n                .setValue(this.plugin.settings.enable_events)\r\n                .onChange(async (enable_events: boolean) => {\r\n                    // The toggle was clicked.\r\n                    this.plugin.settings.enable_events = enable_events;\r\n                    if (enable_events) {\r\n                        // Register events.\r\n                        this.plugin.registerSC_Events(true);\r\n                    } else {\r\n                        // Unregister events.\r\n                        this.plugin.unregisterSC_Events();\r\n                    }\r\n                    await this.plugin.saveSettings();\r\n                }),\r\n            )\r\n        ;\r\n\r\n        // A list of current enable events\r\n        container_element.createEl(\"p\", {text: \"The following gives just a quick glance over which events are enabled on which shell commands. To enable/disable events for a shell command, go to the particular shell command's settings via the 'Shell commands' tab. The list is only updated when you reopen the whole settings panel.\"});\r\n        let found_enabled_event = false;\r\n        getSC_Events(this.plugin).forEach((sc_event: SC_Event) => {\r\n            const event_enabled_t_shell_commands = sc_event.getTShellCommands();\r\n            // Has the event been enabled for any shell commands?\r\n            if (event_enabled_t_shell_commands.length) {\r\n                // Yes, it's enabled.\r\n                // Show a list of shell commands\r\n                const paragraph_element = container_element.createEl(\"p\", {text: sc_event.static().getTitle()});\r\n                const list_element = paragraph_element.createEl(\"ul\");\r\n                event_enabled_t_shell_commands.forEach((t_shell_command: TShellCommand) => {\r\n                    list_element.createEl(\"li\", {text: t_shell_command.getAliasOrShellCommand()});\r\n                });\r\n                found_enabled_event = true;\r\n            }\r\n        });\r\n        if (!found_enabled_event) {\r\n            container_element.createEl(\"p\", {text: \"No events are enabled for any shell commands.\"});\r\n        }\r\n    }\r\n\r\n    private tabVariables(container_element: HTMLElement)\r\n    {\r\n        // \"Preview variables in command palette\" field\r\n        new Setting(container_element)\r\n            .setName(\"Preview variables in command palette and menus\")\r\n            .setDesc(\"If on, variable names are substituted with their realtime values when you view your commands in the command palette and right click context menus (if used). A nice way to ensure your commands will use correct values.\")\r\n            .addToggle(checkbox => checkbox\r\n                .setValue(this.plugin.settings.preview_variables_in_command_palette)\r\n                .onChange(async (value: boolean) => {\r\n                    debugLog(\"Changing preview_variables_in_command_palette to \" + value);\r\n                    this.plugin.settings.preview_variables_in_command_palette = value;\r\n                    await this.plugin.saveSettings();\r\n                })\r\n            )\r\n        ;\r\n\r\n        // \"Show autocomplete menu\" field\r\n        new Setting(container_element)\r\n            .setName(\"Show autocomplete menu\")\r\n            .setDesc(\"If on, a dropdown menu shows up when you begin writing {{variable}} names, showing matching variables and their instructions. Also allows defining custom suggestions in autocomplete.yaml file - see the documentation.\")\r\n            .addToggle(checkbox => checkbox\r\n                .setValue(this.plugin.settings.show_autocomplete_menu)\r\n                .onChange(async (value: boolean) => {\r\n                    debugLog(\"Changing show_autocomplete_menu to \" + value);\r\n                    this.plugin.settings.show_autocomplete_menu = value;\r\n                    this.display(); // Re-render the whole settings view to apply the change.\r\n                    await this.plugin.saveSettings();\r\n                }),\r\n            )\r\n            .addExtraButton(extra_button => extra_button\r\n                .setIcon(\"help\")\r\n                .setTooltip(\"Documentation: Autocomplete\")\r\n                .onClick(() => {\r\n                    gotoURL(DocumentationAutocompleteLink);\r\n                }),\r\n            )\r\n        ;\r\n\r\n        // Custom variables\r\n        new Setting(container_element)\r\n            .setName(\"Custom variables\")\r\n            .setHeading() // Make the \"Variables\" text bold.\r\n            .addExtraButton(extra_button => extra_button\r\n                .setIcon(\"pane-layout\")\r\n                .setTooltip(\"Open a pane that displays all custom variables and their values.\")\r\n                .onClick(() => {\r\n                    this.plugin.createCustomVariableView();\r\n                }),\r\n            )\r\n            .addExtraButton(extra_button => extra_button\r\n                .setIcon(\"help\")\r\n                .setTooltip(\"Documentation: Custom variables\")\r\n                .onClick(() => {\r\n                    gotoURL(DocumentationCustomVariablesLink);\r\n                }),\r\n            )\r\n        ;\r\n\r\n        // Settings for each CustomVariable\r\n        const custom_variable_model = getModel<CustomVariableModel>(CustomVariableModel.name);\r\n        const custom_variable_container = container_element.createDiv();\r\n        this.plugin.getCustomVariableInstances().forEach((custom_variable_instance: CustomVariableInstance) => {\r\n            custom_variable_model.createSettingFields(custom_variable_instance, custom_variable_container);\r\n        });\r\n        createNewModelInstanceButton<CustomVariableModel, CustomVariableInstance>(this.plugin, CustomVariableModel.name, container_element, custom_variable_container, this.plugin.settings).then();\r\n\r\n\r\n        // Built-in variable instructions\r\n        new Setting(container_element)\r\n            .setName(\"Built-in variables\")\r\n            .setHeading() // Make the \"Variables\" text bold.\r\n            .addExtraButton(extra_button => extra_button\r\n                .setIcon(\"help\")\r\n                .setTooltip(\"Documentation: Built-in variables\")\r\n                .onClick(() => {\r\n                    gotoURL(DocumentationBuiltInVariablesIndexLink);\r\n                }),\r\n            )\r\n        ;\r\n\r\n        for (const variable of this.plugin.getVariables()) {\r\n            if (!(variable instanceof CustomVariable)) {\r\n                const variableSettingGroupElement = container_element.createDiv();\r\n                variableSettingGroupElement.addClass(\"SC-setting-group\");\r\n\r\n                // Variable name and documentation link\r\n                const variableHeadingSetting = new Setting(variableSettingGroupElement) // Use container_element instead of variableSettingGroup.\r\n                    .setHeading()\r\n                    .addExtraButton(extraButton => extraButton\r\n                        .setIcon(\"help\")\r\n                        .setTooltip(\"Documentation: \" + variable.getFullName() + \" variable\")\r\n                        .onClick(() => gotoURL(variable.getDocumentationLink()))\r\n                    )\r\n                ;\r\n                variableHeadingSetting.nameEl.insertAdjacentHTML(\"afterbegin\", variable.getHelpName());\r\n\r\n                // Variable description\r\n                const variableDescriptionSetting = new Setting(variableSettingGroupElement)\r\n                    .setClass(\"SC-full-description\") // Without this, description would be shrunk to 50% of space. This setting does not have control elements, so 100% width is ok.\r\n                ;\r\n                variableDescriptionSetting.descEl.insertAdjacentHTML(\"afterbegin\", variable.help_text);\r\n                const availability_text: string = variable.getAvailabilityText();\r\n                if (availability_text) {\r\n                    variableDescriptionSetting.descEl.insertAdjacentHTML(\"beforeend\", \"<br>\" + availability_text);\r\n                }\r\n\r\n                // Variable default value\r\n                const defaultValueSettingTitle = \"Default value for \"+variable.getFullName();\r\n                if (variable.isAlwaysAvailable()) {\r\n                    new Setting(variableSettingGroupElement)\r\n                        .setName(defaultValueSettingTitle)\r\n                        .setDesc(variable.getFullName() + \" is always available, so it cannot have a default value.\")\r\n                    ;\r\n                } else {\r\n                    createVariableDefaultValueField(\r\n                        this.plugin,\r\n                        variableSettingGroupElement,\r\n                        defaultValueSettingTitle,\r\n                        variable,\r\n                    );\r\n                }\r\n            }\r\n        }\r\n\r\n        container_element.createEl(\"p\", {text: \"When you type variables into commands, a preview text appears under the command field to show how the command will look like when it gets executed with variables substituted with their real values.\"});\r\n        container_element.createEl(\"p\", {text: \"Special characters in variable values are tried to be escaped (except if you use CMD as the shell in Windows). This is to improve security so that a variable won't accidentally cause bad things to happen. If you want to use a raw, unescaped value, add an exclamation mark before the variable's name, e.g. {{!title}}, but be careful, it's dangerous!\"});\r\n        container_element.createEl(\"p\", {text: \"There is no way to prevent variable parsing. If you need {{ }} characters in your command, they won't be parsed as variables as long as they do not contain any of the variable names listed above. If you need to pass e.g. {{title}} literally to your command, there is no way to do it atm, please create a discussion in GitHub.\"});\r\n        container_element.createEl(\"p\", {text: \"All variables that access the current file, may cause the command preview to fail if you had no file panel active when you opened the settings window - e.g. you had focus on graph view instead of a note = no file is currently active. But this does not break anything else than the preview.\"});\r\n    }\r\n\r\n    private tabEnvironments(container_element: HTMLElement) {\r\n        // \"Working directory\" field\r\n        new Setting(container_element)\r\n            .setName(\"Working directory\")\r\n            .setDesc(\"A directory where your commands will be run. If empty, defaults to your vault's location. Can be relative (= a folder in the vault) or absolute (= complete from filesystem root).\")\r\n            .addText(text => text\r\n                .setPlaceholder(getVaultAbsolutePath(this.app))\r\n                .setValue(this.plugin.settings.working_directory)\r\n                .onChange(async (value) => {\r\n                    debugLog(\"Changing working_directory to \" + value);\r\n                    this.plugin.settings.working_directory = value;\r\n                    await this.plugin.saveSettings();\r\n                })\r\n            )\r\n        ;\r\n\r\n        // Platforms' default shells\r\n        createShellSelectionField(this.plugin, container_element, this.plugin.settings.default_shells, true);\r\n\r\n        // PATH environment variable fields\r\n        createPATHAugmentationFields(this.plugin, container_element, this.plugin.settings.environment_variable_path_augmentations);\r\n    }\r\n\r\n    private tabPreactions(container_element: HTMLElement) {\r\n\r\n        // Prompts\r\n        const prompt_model = getModel<PromptModel>(PromptModel.name);\r\n        new Setting(container_element)\r\n            .setName(\"Prompts\")\r\n            .setHeading() // Make the \"Prompts\" text to appear as a heading.\r\n        ;\r\n        const prompts_container_element = container_element.createDiv();\r\n        this.plugin.getPrompts().forEach((prompt: Prompt) => {\r\n            prompt_model.createSettingFields(prompt, prompts_container_element);\r\n        });\r\n\r\n        // 'New prompt' button\r\n        const new_prompt_button_promise = createNewModelInstanceButton<PromptModel, Prompt>(this.plugin, PromptModel.name, container_element, prompts_container_element, this.plugin.settings);\r\n        new_prompt_button_promise.then((result: {instance: Prompt, main_setting: Setting}) => {\r\n            prompt_model.openSettingsModal(result.instance, result.main_setting); // Open the prompt settings modal, as the user will probably want to configure it now anyway.\r\n        });\r\n    }\r\n\r\n    private tabOutput(container_element: HTMLElement) {\r\n\r\n        // Output wrappers\r\n        const output_wrapper_model = getModel<OutputWrapperModel>(OutputWrapperModel.name);\r\n        new Setting(container_element)\r\n            .setName(\"Output wrappers\")\r\n            .setHeading() // Make the \"Output wrappers\" text to appear as a heading.\r\n            .addExtraButton(extra_button => extra_button\r\n                .setIcon(\"help\")\r\n                .setTooltip(\"Documentation: Output wrappers\")\r\n                .onClick(() => gotoURL(DocumentationOutputWrappersLink))\r\n            )\r\n        ;\r\n        const output_wrappers_container_element = container_element.createDiv();\r\n        this.plugin.getOutputWrappers().forEach((output_wrapper: OutputWrapper) => {\r\n            output_wrapper_model.createSettingFields(output_wrapper, output_wrappers_container_element);\r\n        });\r\n\r\n        // 'New output wrapper' button\r\n        const new_output_wrapper_button_promise = createNewModelInstanceButton<OutputWrapperModel, OutputWrapper>(this.plugin, OutputWrapperModel.name, container_element, output_wrappers_container_element, this.plugin.settings);\r\n        new_output_wrapper_button_promise.then((result: {instance: OutputWrapper, main_setting: Setting}) => {\r\n            output_wrapper_model.openSettingsModal(result.instance, result.main_setting); // Open the output wrapper settings modal, as the user will probably want to configure it now anyway.\r\n        });\r\n\r\n\r\n        // \"Error message duration\" field\r\n        this.createNotificationDurationField(container_element, \"Error message duration\", \"Concerns messages about failed shell commands.\", \"error_message_duration\");\r\n\r\n        // \"Notification message duration\" field\r\n        this.createNotificationDurationField(container_element, \"Notification message duration\", \"Concerns informational, non-fatal messages, e.g. output directed to 'Notification balloon'.\", \"notification_message_duration\");\r\n\r\n        // \"Show a notification when executing shell commands\" field\r\n        new Setting(container_element)\r\n            .setName(\"Show a notification when executing shell commands\")\r\n            .addDropdown(dropdown_component => dropdown_component\r\n                .addOptions({\r\n                    \"disabled\": \"Do not show\",\r\n                    \"quick\": \"Show for \" + this.plugin.settings.notification_message_duration + \" seconds\",\r\n                    \"permanent\": \"Show until the process is finished\",\r\n                    \"if-long\": \"Show only if executing takes long\",\r\n                })\r\n                .setValue(this.plugin.settings.execution_notification_mode)\r\n                .onChange(async (new_execution_notification_mode: string) => {\r\n                    // Save the change.\r\n                    this.plugin.settings.execution_notification_mode = new_execution_notification_mode as ExecutionNotificationMode;\r\n                    await this.plugin.saveSettings();\r\n                }),\r\n            )\r\n        ;\r\n\r\n        // \"Output channel 'Clipboard' displays a notification message, too\" field\r\n        new Setting(container_element)\r\n            .setName(\"Output channel 'Clipboard' displays a notification message, too\")\r\n            .setDesc(\"If a shell command's output is directed to the clipboard, also show the output in a popup box on the top right corner. This helps to notice what was inserted into clipboard.\")\r\n            .addToggle(checkbox => checkbox\r\n                .setValue(this.plugin.settings.output_channel_clipboard_also_outputs_to_notification)\r\n                .onChange(async (value: boolean) => {\r\n                    this.plugin.settings.output_channel_clipboard_also_outputs_to_notification = value;\r\n                    await this.plugin.saveSettings();\r\n                }),\r\n            )\r\n        ;\r\n    }\r\n\r\n    private createNotificationDurationField(container_element: HTMLElement, title: string, description: string, setting_name: \"error_message_duration\" | \"notification_message_duration\") {\r\n        new Setting(container_element)\r\n            .setName(title)\r\n            .setDesc(description + \" In seconds, between 1 and 180.\")\r\n            .addText(field => field\r\n                .setValue(String(this.plugin.settings[setting_name]))\r\n                .onChange(async (duration_string: string) => {\r\n                    const duration: number = parseInt(duration_string);\r\n                    if (duration >= 1 && duration <= 180) {\r\n                        debugLog(\"Change \" + setting_name + \" from \" + this.plugin.settings[setting_name] + \" to \" + duration);\r\n                        this.plugin.settings[setting_name] = duration;\r\n                        await this.plugin.saveSettings();\r\n                        debugLog(\"Changed.\");\r\n                    }\r\n                    // Don't show a notice if duration is not between 1 and 180, because this function is called every time a user types in this field, so the value might not be final.\r\n                })\r\n            )\r\n        ;\r\n    }\r\n\r\n    private last_position: {\r\n        scroll_position: number;\r\n        tab_name: string;\r\n    } = {\r\n        scroll_position: 0,\r\n        tab_name: \"main-shell-commands\",\r\n    };\r\n    private rememberLastPosition(container_element: HTMLElement) {\r\n        const last_position = this.last_position;\r\n\r\n        // Go to last position now\r\n        this.tab_structure.buttons[last_position.tab_name].click();\r\n        window.setTimeout(() => { // Need to delay the scrolling a bit. Without this, something else would override scrolling and scroll back to 0.\r\n            container_element.scrollTo({\r\n                top: this.last_position.scroll_position,\r\n                behavior: \"auto\",\r\n            });\r\n        }, 0); // 'timeout' can be 0 ms, no need to wait any longer.\r\n\r\n        // Listen to changes\r\n        container_element.addEventListener(\"scroll\", (event) => {\r\n            this.last_position.scroll_position = container_element.scrollTop;\r\n        });\r\n        for (const tab_name in this.tab_structure.buttons) {\r\n            const button = this.tab_structure.buttons[tab_name];\r\n            button.onClickEvent((event: MouseEvent) => {\r\n                last_position.tab_name = tab_name;\r\n            });\r\n        }\r\n    }\r\n}\r\n\r\nexport interface SettingFieldGroup {\r\n    name_setting: Setting;\r\n    shell_command_setting: Setting;\r\n    preview_setting: Setting;\r\n}\r\n\r\nexport interface SettingFieldGroupContainer {\r\n    [key: string]: SettingFieldGroup,\r\n}","/**\r\n * Copied 2021-10-29 from https://gist.github.com/TheDistantSea/8021359\r\n * Modifications:\r\n *  - Made compatible with TypeScript by adding type definitions.\r\n *  - Changed var to let.\r\n *\r\n * Compares two software version numbers (e.g. \"1.7.1\" or \"1.2b\").\r\n *\r\n * This function was born in http://stackoverflow.com/a/6832721.\r\n *\r\n * @param {string} v1 The first version to be compared.\r\n * @param {string} v2 The second version to be compared.\r\n * @param {object} [options] Optional flags that affect comparison behavior:\r\n * <ul>\r\n *     <li>\r\n *         <tt>lexicographical: true</tt> compares each part of the version strings lexicographically instead of\r\n *         naturally; this allows suffixes such as \"b\" or \"dev\" but will cause \"1.10\" to be considered smaller than\r\n *         \"1.2\".\r\n *     </li>\r\n *     <li>\r\n *         <tt>zeroExtend: true</tt> changes the result if one version string has less parts than the other. In\r\n *         this case the shorter string will be padded with \"zero\" parts instead of being considered smaller.\r\n *     </li>\r\n * </ul>\r\n * @returns {number|NaN}\r\n * <ul>\r\n *    <li>0 if the versions are equal</li>\r\n *    <li>a negative integer iff v1 < v2</li>\r\n *    <li>a positive integer iff v1 > v2</li>\r\n *    <li>NaN if either version string is in the wrong format</li>\r\n * </ul>\r\n *\r\n * @copyright by Jon Papaioannou ([\"john\", \"papaioannou\"].join(\".\") + \"@gmail.com\")\r\n * @license This function is in the public domain. Do what you want with it, no strings attached.\r\n */\r\nexport function versionCompare(v1: string, v2: string, options: {lexicographical?: boolean, zeroExtend?: boolean} = {}) {\r\n    let lexicographical = options && options.lexicographical,\r\n        zeroExtend = options && options.zeroExtend,\r\n        v1parts: any = v1.split('.'),\r\n        v2parts: any = v2.split('.');\r\n\r\n    function isValidPart(x: string) {\r\n        return (lexicographical ? /^\\d+[A-Za-z]*$/ : /^\\d+$/).test(x);\r\n    }\r\n\r\n    if (!v1parts.every(isValidPart) || !v2parts.every(isValidPart)) {\r\n        return NaN;\r\n    }\r\n\r\n    if (zeroExtend) {\r\n        while (v1parts.length < v2parts.length) v1parts.push(\"0\");\r\n        while (v2parts.length < v1parts.length) v2parts.push(\"0\");\r\n    }\r\n\r\n    if (!lexicographical) {\r\n        v1parts = v1parts.map(Number);\r\n        v2parts = v2parts.map(Number);\r\n    }\r\n\r\n    for (let i = 0; i < v1parts.length; ++i) {\r\n        if (v2parts.length == i) {\r\n            return 1;\r\n        }\r\n\r\n        if (v1parts[i] == v2parts[i]) {\r\n            continue;\r\n        }\r\n        else if (v1parts[i] > v2parts[i]) {\r\n            return 1;\r\n        }\r\n        else {\r\n            return -1;\r\n        }\r\n    }\r\n\r\n    if (v1parts.length != v2parts.length) {\r\n        return -1;\r\n    }\r\n\r\n    return 0;\r\n}","/*\r\n * 'Shell commands' plugin for Obsidian.\r\n * Copyright (C) 2021 - 2023 Jarkko Linnanvirta\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, version 3.0 of the License.\r\n *\r\n * This program is distributed in the hope that it will be useful,\r\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n * GNU General Public License for more details.\r\n *\r\n * You should have received a copy of the GNU General Public License\r\n * along with this program. If not, see <https://www.gnu.org/licenses/>.\r\n *\r\n * Contact the author (Jarkko Linnanvirta): https://github.com/Taitava/\r\n */\r\n\r\nimport {\r\n\tCustomVariable,\r\n\tCustomVariableInstanceMap,\r\n\tCustomVariableModel,\r\n\tCustomVariableView,\r\n\tgetIDGenerator,\r\n\tgetModel,\r\n\tintroduceModels,\r\n\tPromptMap,\r\n\tPromptModel,\r\n\tShellCommandExecutor,\r\n} from \"./imports\";\r\nimport {\r\n    Command,\r\n    Notice,\r\n    ObsidianProtocolData,\r\n    Plugin,\r\n    setIcon,\r\n    WorkspaceLeaf,\r\n} from 'obsidian';\r\nimport {\r\n\tcombineObjects,\r\n\tgenerateObsidianCommandName,\r\n\tgetOperatingSystem,\r\n\tgetPluginAbsolutePath,\r\n} from \"./Common\";\r\nimport {RunMigrations} from \"./Migrations\";\r\nimport {\r\n    newShellCommandConfiguration,\r\n    ShellCommandConfiguration,\r\n} from \"./settings/ShellCommandConfiguration\";\r\nimport {\r\n\tgetDefaultSettings,\r\n\tSettingsVersionString,\r\n\tSC_MainSettings,\r\n} from \"./settings/SC_MainSettings\";\r\nimport {ObsidianCommandsContainer} from \"./ObsidianCommandsContainer\";\r\nimport {SC_MainSettingsTab} from \"./settings/SC_MainSettingsTab\";\r\nimport * as path from \"path\";\r\nimport * as fs from \"fs\";\r\nimport {ShellCommandParsingProcess, TShellCommand, TShellCommandContainer} from \"./TShellCommand\";\r\nimport {getUsersDefaultShell} from \"./Shell\";\r\nimport {versionCompare} from \"./lib/version_compare\";\r\nimport {debugLog, setDEBUG_ON} from \"./Debug\";\r\nimport {addCustomAutocompleteItems} from \"./settings/setting_elements/Autocomplete\";\r\nimport {getSC_Events} from \"./events/SC_EventList\";\r\nimport {SC_Event} from \"./events/SC_Event\";\r\nimport {\r\n\tloadVariables,\r\n\tVariableSet,\r\n} from \"./variables/loadVariables\";\r\nimport {\r\n    OutputWrapperMap,\r\n    OutputWrapperModel,\r\n} from \"./models/output_wrapper/OutputWrapperModel\";\r\nimport {ParsingResult} from \"./variables/parseVariables\";\r\nimport {AutocompleteResult} from \"autocompleter/autocomplete\";\r\n\r\nexport default class SC_Plugin extends Plugin {\r\n\t/**\r\n\t * Defines the settings structure version. Change this when a new plugin version is released, but only if that plugin\r\n\t * version introduces changes to the settings structure. Do not change if the settings structure stays unchanged.\r\n\t */\r\n\tpublic static SettingsVersion: SettingsVersionString = \"0.18.0\";\r\n\r\n\tpublic settings: SC_MainSettings; // TODO: Rename to 'configuration'.\r\n\tpublic obsidian_commands: ObsidianCommandsContainer = {};\r\n\tprivate t_shell_commands: TShellCommandContainer = {};\r\n\tprivate prompts: PromptMap;\r\n\tprivate custom_variable_instances: CustomVariableInstanceMap;\r\n\tprivate variables: VariableSet;\r\n    private output_wrappers: OutputWrapperMap;\r\n\r\n\t/**\r\n\t * Holder for shell commands and aliases, whose variables are parsed before the actual execution during command\r\n\t * palette preview. This array gets emptied after every time a shell command is executed via the command palette.\r\n\t *\r\n\t * This is only used for command palette, not when executing a shell command from the settings panel, nor when\r\n\t * executing shell commands via SC_Events.\r\n\t *\r\n\t * @private\r\n\t */\r\n\tprivate cached_parsing_processes: {\r\n\t\t[key: string]: ShellCommandParsingProcess | undefined,\r\n\t} = {};\r\n\r\n\tpublic static readonly SHELL_COMMANDS_URI_ACTION = \"shell-commands\";\r\n\r\n    /** @see getOutputStatusBarElement() */\r\n    private statusBarElement: HTMLElement;\r\n\r\n    private autocompleteMenus: AutocompleteResult[] = [];\r\n\r\n\tpublic async onload() {\r\n\t\tdebugLog('loading plugin');\r\n\r\n\t\t// Load settings\r\n\t\tif (!await this.loadSettings()) {\r\n\t\t\t// Loading the settings has failed due to an unsupported settings file version.\r\n\t\t\t// The plugin should not be used, and it has actually disabled itself, but the code execution needs to be\r\n\t\t\t// stopped manually.\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\t// Define models\r\n\t\tintroduceModels(this);\r\n\r\n\t\t// Run possible configuration migrations\r\n\t\tawait RunMigrations(this);\r\n\r\n\t\t// Generate TShellCommand objects from configuration (only after configuration migrations are done)\r\n\t\tthis.loadTShellCommands();\r\n\r\n\t\t// Load Prompts\r\n\t\tconst prompt_model = getModel<PromptModel>(PromptModel.name);\r\n\t\tthis.prompts = prompt_model.loadInstances(this.settings);\r\n\r\n\t\t// Load CustomVariables (configuration instances)\r\n\t\tconst custom_variable_model = getModel<CustomVariableModel>(CustomVariableModel.name);\r\n\t\tthis.custom_variable_instances = custom_variable_model.loadInstances(this.settings);\r\n\r\n\t\t// Load variables (both built-in and custom ones). Do this AFTER loading configs for custom variables!\r\n\t\tthis.variables = loadVariables(this);\r\n\r\n        // Load output wrappers\r\n        const output_wrapper_model = getModel<OutputWrapperModel>(OutputWrapperModel.name);\r\n        this.output_wrappers = output_wrapper_model.loadInstances(this.settings);\r\n\r\n\t\t// Make all defined shell commands to appear in the Obsidian command palette.\r\n\t\tconst shell_commands = this.getTShellCommands();\r\n\t\tfor (const shell_command_id in shell_commands) {\r\n\t\t\tconst t_shell_command = shell_commands[shell_command_id];\r\n\t\t\tif (t_shell_command.canAddToCommandPalette()) {\r\n\t\t\t\tthis.registerShellCommand(t_shell_command);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// Perform event registrations, if enabled.\r\n\t\tif (this.settings.enable_events) {\r\n\t\t\tthis.registerSC_Events(false);\r\n\t\t}\r\n\r\n\t\t// Load a custom autocomplete list if it exists.\r\n\t\tthis.loadCustomAutocompleteList();\r\n\r\n\t\t// Create a SettingsTab.\r\n\t\tthis.addSettingTab(new SC_MainSettingsTab(this.app, this));\r\n\r\n\t\t// Make it possible to create CustomVariableViews.\r\n\t\tthis.registerView(CustomVariableView.ViewType, (leaf: WorkspaceLeaf) => new CustomVariableView(this, leaf));\r\n\r\n\t\t// Debug reserved IDs\r\n\t\tdebugLog(\"IDGenerator's reserved IDs:\");\r\n\t\tdebugLog(getIDGenerator().getReservedIDs());\r\n\r\n\t\t// Register an URI handler.\r\n\t\tthis.registerURIHandler();\r\n\t}\r\n\r\n\tprivate loadTShellCommands() {\r\n\t\tthis.t_shell_commands = {}; // TODO: Consider changing this to either an array or a Map.\r\n\t\tconst shell_command_configurations = this.getShellCommandConfigurations();\r\n\r\n\t\tfor (const shell_command_configuration of shell_command_configurations) {\r\n\t\t\tthis.t_shell_commands[shell_command_configuration.id] = new TShellCommand(this, shell_command_configuration);\r\n\t\t}\r\n\t}\r\n\r\n\tpublic getTShellCommands() {\r\n\t\treturn this.t_shell_commands;\r\n\t}\r\n\r\n\tpublic getVariables() {\r\n\t\treturn this.variables;\r\n\t}\r\n\r\n\tpublic getPrompts() {\r\n\t\treturn this.prompts;\r\n\t}\r\n\r\n\tpublic getCustomVariableInstances(): CustomVariableInstanceMap {\r\n\t\treturn this.custom_variable_instances;\r\n\t}\r\n\r\n\tprivate getShellCommandConfigurations(): ShellCommandConfiguration[] {\r\n\t\treturn this.settings.shell_commands;\r\n\t}\r\n\r\n\tpublic getOutputWrappers() {\r\n\t\treturn this.output_wrappers;\r\n\t}\r\n\r\n    /**\r\n     * Tries to find an index at which a ShellCommandConfiguration object is located in this.settings.shell_commands.\r\n     * Returns undefined, if it's not found.\r\n     *\r\n     * DO NOT EXPOSE THE INDEX OUTSIDE THE PLUGIN! It's not a stable reference to a shell command, because shell commands\r\n     * can be reordered (well, at least in some future version of the plugin). Always use the ID as a stable, externally\r\n     * safe reference!\r\n     *\r\n     * @param shell_command_id\r\n     */\r\n    public getShellCommandConfigurationIndex(shell_command_id: string): number | undefined {\r\n        return this.settings.shell_commands.findIndex((shell_command_configuration: ShellCommandConfiguration) => {\r\n            return shell_command_configuration.id == shell_command_id;\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Returns an Obsidian URI that complies with the format obsidian://action/?vault=XYZ and that may contain possible\r\n     * custom arguments at the end.\r\n     *\r\n     * Note that if 'action' is 'open' and a 'file' argument is present in 'uri_arguments', the URI will use the shorthand syntax described here: https://help.obsidian.md/Advanced+topics/Using+obsidian+URI#Shorthand+formats\r\n     *\r\n     * @param action\r\n     * @param uri_arguments\r\n     */\r\n    public getObsidianURI(action: string, uri_arguments: Record<string, string> = {}): string {\r\n        const encoded_vault_name: string = encodeURIComponent(this.app.vault.getName());\r\n        let base_uri: string;\r\n\r\n        // Check which kind of uri type should be used: shorthand or normal\r\n        if (\"open\" === action && uri_arguments.file !== undefined) {\r\n            // Use shorthand uri type for opening a file.\r\n            const encoded_file = encodeURIComponent(uri_arguments.file);\r\n            base_uri = `obsidian://vault/${encoded_vault_name}/${encoded_file}`;\r\n            delete uri_arguments.file; // Prevent adding an extra '&file=' argument to the end of the URI.\r\n        } else {\r\n            // Use normal uri type for everything else.\r\n            base_uri = `obsidian://${action}/?vault=${encoded_vault_name}`;\r\n        }\r\n        let concatenated_uri_arguments = \"\";\r\n        for (const uri_argument_name in uri_arguments) {\r\n            const uri_argument_value = encodeURIComponent(uri_arguments[uri_argument_name]);\r\n            concatenated_uri_arguments += `&${uri_argument_name}=${uri_argument_value}`;\r\n        }\r\n        return base_uri + concatenated_uri_arguments;\r\n    }\r\n\r\n\t/**\r\n\t * Creates a new shell command object and registers it to Obsidian's command palette, but does not save the modified\r\n\t * configuration to disk. To save the addition, call saveSettings().\r\n\t */\r\n\tpublic newTShellCommand() {\r\n\t\tconst shell_command_id = getIDGenerator().generateID();\r\n\t\tconst shell_command_configuration = newShellCommandConfiguration(shell_command_id);\r\n        this.settings.shell_commands.push(shell_command_configuration);\r\n\t\tconst t_shell_command: TShellCommand = new TShellCommand(this, shell_command_configuration);\r\n\t\tthis.t_shell_commands[shell_command_id] = t_shell_command;\r\n\t\tif (t_shell_command.canAddToCommandPalette()) { // This is probably always true, because the default configuration enables adding to the command palette, but check just in case.\r\n\t\t\tthis.registerShellCommand(t_shell_command);\r\n\t\t}\r\n\t\treturn t_shell_command;\r\n\t}\r\n\r\n\t/**\r\n\t * TODO: Move to TShellCommand.registerToCommandPalette(), but split to multiple methods.\r\n\t *\r\n\t * @param t_shell_command\r\n\t */\r\n\tpublic registerShellCommand(t_shell_command: TShellCommand) {\r\n\t\tconst shell_command_id = t_shell_command.getId();\r\n\t\tdebugLog(\"Registering shell command #\" + shell_command_id + \"...\");\r\n\r\n\t\t// Define a function for executing the shell command.\r\n\t\tconst executor = async (parsing_process: ShellCommandParsingProcess | undefined) => {\r\n\t\t\tif (!parsing_process) {\r\n\t\t\t\tparsing_process = t_shell_command.createParsingProcess(null); // No SC_Event is available when executing shell commands via the command palette / hotkeys.\r\n\t\t\t\t// Try to process variables that can be processed before performing preactions.\r\n\t\t\t\tawait parsing_process.process();\r\n\t\t\t}\r\n\t\t\tif (parsing_process.getParsingResults().shell_command?.succeeded) { // .shell_command should always be present (even if parsing did not succeed), but if it's not, show errors in the else block.\r\n\t\t\t\t// The command was parsed correctly.\r\n\t\t\t\tconst executor_instance = new ShellCommandExecutor( // Named 'executor_instance' because 'executor' is another constant.\r\n\t\t\t\t\tthis,\r\n\t\t\t\t\tt_shell_command,\r\n\t\t\t\t\tnull // No SC_Event is available when executing via command palette or hotkey.\r\n\t\t\t\t);\r\n\t\t\t\tawait executor_instance.doPreactionsAndExecuteShellCommand(parsing_process);\r\n\t\t\t} else {\r\n\t\t\t\t// The command could not be parsed correctly.\r\n\t\t\t\t// Display error messages\r\n\t\t\t\tparsing_process.displayErrorMessages();\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t// Register an Obsidian command\r\n\t\tconst obsidian_command: Command = {\r\n\t\t\tid: this.generateObsidianCommandId(shell_command_id),\r\n\t\t\tname: generateObsidianCommandName(this, t_shell_command.getShellCommand(), t_shell_command.getAlias()), // Will be overridden in command palette, but this will probably show up in hotkey settings panel.\r\n\t\t\t// Use 'checkCallback' instead of normal 'callback' because we also want to get called when the command palette is opened.\r\n\t\t\tcheckCallback: (is_opening_command_palette): boolean | void => { // If is_opening_command_palette is true, then the return type is boolean, otherwise void.\r\n\t\t\t\tif (is_opening_command_palette) {\r\n\t\t\t\t\t// The user is currently opening the command palette.\r\n\r\n\t\t\t\t\t// Check can the shell command be shown in command palette\r\n\t\t\t\t\tif (!t_shell_command.canShowInCommandPalette()) {\r\n\t\t\t\t\t\t// Cancel preview and deny showing in command palette.\r\n\t\t\t\t\t\tdebugLog(\"Shell command #\" + t_shell_command.getId() + \" won't be shown in command palette.\");\r\n\t\t\t\t\t\treturn false;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t// Do not execute the command yet, but parse variables for preview, if enabled in the settings.\r\n\t\t\t\t\tdebugLog(\"Getting command palette preview for shell command #\" + t_shell_command.getId());\r\n\t\t\t\t\tif (this.settings.preview_variables_in_command_palette) {\r\n\t\t\t\t\t\t// Preparse variables\r\n\t\t\t\t\t\tconst parsing_process = t_shell_command.createParsingProcess(null); // No SC_Event is available when executing shell commands via the command palette / hotkeys.\r\n                        parsing_process.process().then((parsing_succeeded) => {\r\n                            if (parsing_succeeded) {\r\n                                // Parsing succeeded\r\n\r\n                                // Rename Obsidian command\r\n                                const parsingResults = parsing_process.getParsingResults();\r\n                                /** Don't confuse this name with ShellCommandParsingResult interface! The properties are very different. TODO: Rename ShellCommandParsingResult to something else. */\r\n                                const shellCommandParsingResult: ParsingResult = parsingResults[\"shell_command\"] as ParsingResult; // Use 'as' to denote that properties exist on this line and below.\r\n                                const aliasParsingResult: ParsingResult = parsingResults[\"alias\"] as ParsingResult;\r\n                                const parsedShellCommand: string = shellCommandParsingResult.parsed_content as string;\r\n                                const parsedAlias: string = aliasParsingResult.parsed_content as string;\r\n                                t_shell_command.renameObsidianCommand(parsedShellCommand,parsedAlias);\r\n\r\n                                // Store the preparsed variables so that they will be used if this shell command gets executed.\r\n                                this.cached_parsing_processes[t_shell_command.getId()] = parsing_process;\r\n                            } else {\r\n                                // Parsing failed, so use unparsed t_shell_command.getShellCommand() and t_shell_command.getAlias().\r\n                                t_shell_command.renameObsidianCommand(t_shell_command.getShellCommand(), t_shell_command.getAlias());\r\n                                this.cached_parsing_processes[t_shell_command.getId()] = undefined;\r\n                            }\r\n                        });\r\n                    } else {\r\n                        // Parsing is disabled, so use unparsed t_shell_command.getShellCommand() and t_shell_command.getAlias().\r\n                        t_shell_command.renameObsidianCommand(t_shell_command.getShellCommand(), t_shell_command.getAlias());\r\n                        this.cached_parsing_processes[t_shell_command.getId()] = undefined;\r\n                    }\r\n\r\n                    return true; // Tell Obsidian this command can be shown in command palette.\r\n\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// The user has instructed to execute the command.\r\n                    executor(\r\n                        this.cached_parsing_processes[t_shell_command.getId()], // Can be undefined, if no preparsing was done. executor() will handle creating the parsing process then.\r\n                    ).then(() => {\r\n\r\n                        // Delete the whole array of preparsed commands. Even though we only used just one command from it, we need to notice that opening a command\r\n                        // palette might generate multiple preparsed commands in the array, but as the user selects and executes only one command, all these temporary\r\n                        // commands are now obsolete. Delete them just in case the user toggles the variable preview feature off in the settings, or executes commands via hotkeys. We do not want to\r\n                        // execute obsolete commands accidentally.\r\n                        // This deletion also needs to be done even if the executed command was not a preparsed command, because\r\n                        // even when preparsing is turned on in the settings, some commands may fail to parse, and therefore they would not be in this array, but other\r\n                        // commands might be.\r\n                        this.cached_parsing_processes = {}; // Removes obsolete preparsed variables from all shell commands.\r\n                        return; // When we are not in the command palette check phase, there's no need to return a value. Just have this 'return' statement because all other return points have a 'return' too.\r\n                    });\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t};\r\n\t\tthis.addCommand(obsidian_command);\r\n\t\tthis.obsidian_commands[shell_command_id] = obsidian_command; // Store the reference so that we can edit the command later in ShellCommandsSettingsTab if needed. TODO: Use tShellCommand instead.\r\n\t\tt_shell_command.setObsidianCommand(obsidian_command);\r\n\t\tdebugLog(\"Registered.\");\r\n\t}\r\n\r\n\r\n\t/**\r\n\t * Goes through all events and all shell commands, and for each shell command, registers all the events that the shell\r\n\t * command as enabled in its configuration. Does not modify the configurations.\r\n\t *\r\n\t * @param called_after_changing_settings Set to: true, if this happens after changing configuration; false, if this happens during loading the plugin.\r\n\t */\r\n\tpublic registerSC_Events(called_after_changing_settings: boolean) {\r\n\t\t// Make sure that Obsidian is fully loaded before allowing any events to trigger.\r\n\t\tthis.app.workspace.onLayoutReady(() => {\r\n\t\t\t// Even after Obsidian is fully loaded, wait a while in order to prevent SC_Event_onActiveLeafChanged triggering right after start-up.\r\n\t\t\t// At least on Obsidian 0.12.19 it's not enough to delay until onLayoutReady, need to wait a bit more in order to avoid the miss-triggering.\r\n\t\t\twindow.setTimeout(() => { // setTimeout() should not need registering to Obsidian API, I guess.\r\n\t\t\t\t// Iterate all shell commands and register possible events.\r\n\t\t\t\tconst shell_commands = this.getTShellCommands();\r\n\t\t\t\tfor (const shell_command_id in shell_commands) {\r\n\t\t\t\t\tconst t_shell_command = shell_commands[shell_command_id];\r\n\t\t\t\t\tt_shell_command.registerSC_Events(called_after_changing_settings);\r\n\t\t\t\t}\r\n\t\t\t}, 0); // 0 means to call the callback on \"the next event cycle\", according to window.setTimeout() documentation. It should be a long enough delay. But if SC_Event_onActiveLeafChanged still gets triggered during start-up, this value can be raised to for example 1000 (= one second).\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Goes through all events and all shell commands, and makes sure all of them are unregistered, e.g. will not trigger\r\n\t * automatically. Does not modify the configurations.\r\n\t */\r\n\tpublic unregisterSC_Events() {\r\n\t\t// Iterate all events\r\n\t\tgetSC_Events(this).forEach((sc_event: SC_Event) => {\r\n\t\t\t// Iterate all shell commands\r\n\t\t\tconst shell_commands = this.getTShellCommands();\r\n\t\t\tfor (const shell_command_id in shell_commands) {\r\n\t\t\t\tconst t_shell_command = shell_commands[shell_command_id];\r\n\t\t\t\tsc_event.unregister(t_shell_command);\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * Defines an Obsidian protocol handler that allows receiving requests via obsidian://shell-commands URI.\r\n\t * @private\r\n\t */\r\n\tprivate registerURIHandler() {\r\n\t\tthis.registerObsidianProtocolHandler(SC_Plugin.SHELL_COMMANDS_URI_ACTION, async (parameters: ObsidianProtocolData) => {\r\n\t\t\tconst parameter_names: string[] = Object.getOwnPropertyNames(parameters);\r\n\r\n\t\t\t// Assign values to custom variables (also delete some unneeded entries from parameter_names)\r\n\t\t\tlet custom_variable_assignments_failed = false;\r\n\t\t\tfor (const parameter_index in parameter_names) {\r\n\t\t\t\tconst parameter_name = parameter_names[parameter_index];\r\n\r\n\t\t\t\t// Check if the parameter name is a custom variable\r\n\t\t\t\tif (parameter_name.match(/^_/)) {\r\n\t\t\t\t\t// This parameter defines a value for a custom variable\r\n\t\t\t\t\t// Find the variable.\r\n\t\t\t\t\tlet found_custom_variable = false;\r\n\t\t\t\t\tfor (const variable of this.getVariables()) {\r\n\t\t\t\t\t\tif (variable instanceof CustomVariable && variable.variable_name === parameter_name) {\r\n\t\t\t\t\t\t\t// Found the correct variable.\r\n\t\t\t\t\t\t\tfound_custom_variable = true;\r\n\r\n\t\t\t\t\t\t\t// Assign the given value to the custom variable.\r\n\t\t\t\t\t\t\tawait variable.setValue(parameters[parameter_name]);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (!found_custom_variable) {\r\n\t\t\t\t\t\tthis.newError(\"Shell commands URI: A custom variable does not exist: \" + parameter_name);\r\n\t\t\t\t\t\tcustom_variable_assignments_failed = true;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tif (!custom_variable_assignments_failed) {\r\n\t\t\t\t// Determine action\r\n\t\t\t\tif (undefined !== parameters.execute) {\r\n\t\t\t\t\t// Execute a shell command.\r\n\t\t\t\t\tconst executable_shell_command_id = parameters.execute;\r\n\t\t\t\t\tparameter_names.remove(\"execute\"); // Mark the parameter as handled. Prevents showing an error message for an unrecognised parameter.\r\n\r\n\t\t\t\t\t// Find the executable shell command\r\n\t\t\t\t\tlet found_t_shell_command = false;\r\n\t\t\t\t\tconst shell_commands = this.getTShellCommands();\r\n\t\t\t\t\tfor (const shell_command_id in shell_commands) {\r\n\t\t\t\t\t\tconst t_shell_command = shell_commands[shell_command_id];\r\n\t\t\t\t\t\tif (t_shell_command.getId() === executable_shell_command_id) {\r\n\t\t\t\t\t\t\t// This is the correct shell command.\r\n\t\t\t\t\t\t\tfound_t_shell_command = true;\r\n\r\n\t\t\t\t\t\t\t// Execute it.\r\n\t\t\t\t\t\t\tconst executor = new ShellCommandExecutor(this, t_shell_command, null);\r\n\t\t\t\t\t\t\tawait executor.doPreactionsAndExecuteShellCommand();\r\n\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (!found_t_shell_command) {\r\n\t\t\t\t\t\tthis.newError(\"Shell commands URI: A shell command id does not exist: \" + executable_shell_command_id);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// Raise errors for any left-over parameters, if exists.\r\n\t\t\tfor (const parameter_name of parameter_names) {\r\n\t\t\t\tswitch (parameter_name) {\r\n\t\t\t\t\tcase \"\": // For some reason Obsidian 0.14.5 adds an empty-named parameter if there are no ?query=parameters present.\r\n\t\t\t\t\tcase \"action\": // Obsidian provides this always. Don't show an error message for this.\r\n\t\t\t\t\tcase \"vault\": // Obsidian handles this parameter automatically. Just make sure no error message is displayed when this is present.\r\n\t\t\t\t\t\t// Do nothing\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tdefault:\r\n\t\t\t\t\t\tif (parameter_name.match(/^_/)) {\r\n\t\t\t\t\t\t\t// Custom variable parameters (and any possible errors related to them) are already handled above.\r\n\t\t\t\t\t\t\t// Do nothing.\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t// Throw an error for everything else.\r\n\t\t\t\t\t\t\tthis.newError(\"Shell commands URI: Unrecognised parameter: \" + parameter_name);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tpublic generateObsidianCommandId(shell_command_id: string) {\r\n\t\treturn \"shell-command-\" + shell_command_id;\r\n\t}\r\n\r\n\tpublic onunload() {\r\n\t\tdebugLog('Unloading Shell commands plugin.');\r\n\r\n\t\t// Close CustomVariableViews.\r\n\t\tthis.app.workspace.detachLeavesOfType(CustomVariableView.ViewType);\r\n\r\n        // Close autocomplete menus.\r\n        for (const autocompleteMenu of this.autocompleteMenus) {\r\n            autocompleteMenu?.destroy();\r\n        }\r\n\t}\r\n\r\n\t/**\r\n\t *\r\n\t * @param current_settings_version\r\n\t * @private\r\n\t * @return True if the given settings version is supported by this plugin version, or an error message string if it's not supported.\r\n\t */\r\n\tprivate isSettingsVersionSupported(current_settings_version: SettingsVersionString) {\r\n\t\tif (current_settings_version === \"prior-to-0.7.0\") {\r\n\t\t\t// 0.x.y supports all old settings formats that do not define a version number. This support will be removed in 1.0.0.\r\n\t\t\treturn true;\r\n\t\t} else {\r\n\t\t\t// Compare the version number\r\n\t\t\t/** Note that the plugin version may be different than what will be used in the version comparison. The plugin version will be displayed in possible error messages. */\r\n\t\t\tconst plugin_version = this.getPluginVersion();\r\n\t\t\tconst version_comparison = versionCompare(SC_Plugin.SettingsVersion, current_settings_version);\r\n\t\t\tif (version_comparison === 0) {\r\n\t\t\t\t// The versions are equal.\r\n\t\t\t\t// Supported.\r\n\t\t\t\treturn true;\r\n\t\t\t} else if (version_comparison < 0) {\r\n\t\t\t\t// The compared version is newer than what the plugin can support.\r\n\t\t\t\treturn \"The settings file is saved by a newer version of this plugin, so this plugin does not support the structure of the settings file. Please upgrade this plugin to at least version \" + current_settings_version + \". Now the plugin version is \" + plugin_version;\r\n\t\t\t} else {\r\n\t\t\t\t// The compared version is older than the version that the plugin currently uses to write settings.\r\n\t\t\t\t// 0.x.y supports all old settings versions. In 1.0.0, some old settings formats might lose their support, but that's not yet certain.\r\n\t\t\t\treturn true;\r\n\t\t\t}\r\n\r\n\t\t}\r\n\t}\r\n\r\n\tpublic getPluginVersion() {\r\n\t\treturn this.manifest.version;\r\n\t}\r\n\r\n\tprivate async loadSettings() {\r\n\r\n\t\t// Try to read a settings file\r\n\t\tlet all_settings: SC_MainSettings;\r\n\t\tthis.settings = await this.loadData(); // May have missing main settings fields, if the settings file is from an older version of SC. It will be migrated later.\r\n\t\tif (null === this.settings) {\r\n\t\t\t// The settings file does not exist.\r\n\t\t\t// Use default settings\r\n\t\t\tthis.settings = getDefaultSettings(true);\r\n\t\t\tall_settings = this.settings;\r\n\t\t} else {\r\n\t\t\t// Succeeded to load a settings file.\r\n\t\t\t// In case the settings file does not have 'debug' or 'settings_version' fields, create them.\r\n\t\t\tall_settings = combineObjects(getDefaultSettings(false), this.settings); // This temporary settings object always has all fields defined (except sub fields, such as shell command specific fields, may still be missing, but they are not needed this early). This is used so that it's certain that the fields 'debug' and 'settings_version' exist.\r\n\t\t}\r\n\r\n\t\t// Update debug status - before this line debugging is always OFF!\r\n\t\tsetDEBUG_ON(all_settings.debug);\r\n\r\n\t\t// Ensure that the loaded settings file is supported.\r\n\t\tconst version_support = this.isSettingsVersionSupported(all_settings.settings_version);\r\n\t\tif (typeof version_support === \"string\") {\r\n\t\t\t// The settings version is not supported.\r\n\t\t\tnew Notice(\"SHELL COMMANDS PLUGIN HAS DISABLED ITSELF in order to prevent misinterpreting settings / corrupting the settings file!\", 120*1000);\r\n\t\t\tnew Notice(version_support as string, 120*1000);\r\n\t\t\tawait this.disablePlugin();\r\n\t\t\treturn false; // The plugin should not be used.\r\n\t\t}\r\n\t\treturn true; // Settings are loaded and the plugin can be used.\r\n\t}\r\n\r\n\tpublic async saveSettings() {\r\n\t\t// Update settings version in case it's old.\r\n\t\tthis.settings.settings_version = SC_Plugin.SettingsVersion;\r\n\r\n\t\t// Write settings\r\n\t\tawait this.saveData(this.settings);\r\n\t}\r\n\r\n\tprivate loadCustomAutocompleteList() {\r\n\t\tconst custom_autocomplete_file_name = \"autocomplete.yaml\";\r\n\t\tconst custom_autocomplete_file_path = path.join(getPluginAbsolutePath(this), custom_autocomplete_file_name);\r\n\r\n\t\tif (fs.existsSync(custom_autocomplete_file_path)) {\r\n\t\t\tdebugLog(\"loadCustomAutocompleteList(): \" + custom_autocomplete_file_name + \" exists, will load it now.\");\r\n\t\t\tconst custom_autocomplete_content = fs.readFileSync(custom_autocomplete_file_path).toLocaleString();\r\n\t\t\tconst result = addCustomAutocompleteItems(custom_autocomplete_content);\r\n\t\t\tif (true === result) {\r\n\t\t\t\t// OK\r\n\t\t\t\tdebugLog(\"loadCustomAutocompleteList(): \" + custom_autocomplete_file_name + \" loaded.\");\r\n\t\t\t} else {\r\n\t\t\t\t// An error has occurred.\r\n\t\t\t\tdebugLog(\"loadCustomAutocompleteList(): \" + result);\r\n\t\t\t\tthis.newError(\"Shell commands: Unable to parse \" + custom_autocomplete_file_name + \": \" + result);\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tdebugLog(\"loadCustomAutocompleteList(): \" + custom_autocomplete_file_name + \" does not exists, so won't load it. This is perfectly ok.\");\r\n\t\t}\r\n\r\n\t}\r\n\r\n    /**\r\n     * Puts the given Autocomplete menu into a list of menus that will be destroyed when the plugin unloads.\r\n     * @param autocompleteMenu\r\n     */\r\n    public registerAutocompleteMenu(autocompleteMenu: AutocompleteResult) {\r\n        this.autocompleteMenus.push(autocompleteMenu);\r\n    }\r\n\r\n\tprivate async disablePlugin() {\r\n\t\t// This unfortunately accesses a private API.\r\n\t\t// @ts-ignore\r\n\t\tawait this.app.plugins.disablePlugin(this.manifest.id);\r\n\t}\r\n\r\n\tpublic getPluginId() {\r\n\t\treturn this.manifest.id;\r\n\t}\r\n\r\n\tpublic getPluginName() {\r\n\t\treturn this.manifest.name;\r\n\t}\r\n\r\n\tpublic newError(\r\n        message: string,\r\n        timeout: number = this.getErrorMessageDurationMs(),\r\n    ) {\r\n\t\treturn new Notice(message, timeout);\r\n\t}\r\n\r\n\tpublic newErrors(messages: string[]) {\r\n\t\tmessages.forEach((message: string) => {\r\n\t\t\tthis.newError(message);\r\n\t\t});\r\n\t}\r\n\r\n    /**\r\n     *\r\n     * @param message\r\n     * @param timeout Custom timeout in milliseconds. If not set, the timeout will be fetched from user configurable settings. Use 0 if you want to disable the timeout, i.e. show the notification until it's explicitly hidden by clinking it, or via code.\r\n     */\r\n\tpublic newNotification(\r\n        message: string,\r\n        timeout = this.getNotificationMessageDurationMs(),\r\n    ) {\r\n\t\treturn new Notice(message, timeout);\r\n\t}\r\n\r\n    public getNotificationMessageDurationMs(): number {\r\n        return this.settings.notification_message_duration * 1000; // * 1000 = convert seconds to milliseconds.\r\n    }\r\n\r\n    public getErrorMessageDurationMs(): number {\r\n        return this.settings.error_message_duration * 1000; // * 1000 = convert seconds to milliseconds.\r\n    }\r\n\r\n\tpublic getDefaultShell(): string {\r\n\t\tconst operating_system = getOperatingSystem();\r\n\t\tlet shell_name = this.settings.default_shells[operating_system]; // Can also be undefined.\r\n\t\tif (undefined === shell_name) {\r\n\t\t\tshell_name = getUsersDefaultShell();\r\n\t\t}\r\n\t\treturn shell_name;\r\n\t}\r\n\r\n\tpublic createCustomVariableView(): void {\r\n\t\tconst leaf = this.app.workspace.getRightLeaf(false);\r\n\t\tleaf.setViewState({\r\n\t\t\ttype: CustomVariableView.ViewType,\r\n\t\t\tactive: true,\r\n\t\t}).then();\r\n\t\tthis.app.workspace.revealLeaf(leaf);\r\n\t}\r\n\r\n\t/**\r\n\t * Called when CustomVariable values are changed.\r\n\t */\r\n\tpublic async updateCustomVariableViews() {\r\n\t\tfor (const leaf of this.app.workspace.getLeavesOfType(CustomVariableView.ViewType)) {\r\n\t\t\tawait (leaf.view as CustomVariableView).updateContent();\r\n\t\t}\r\n\t}\r\n\r\n    /**\r\n     * Used by OutputChannel_StatusBar.\r\n     * TODO: Make it possible to have multiple status bar elements. It should be a shell command level setting, where a shell command opts for either to use their own status bar element, or a common one.\r\n     */\r\n    public getOutputStatusBarElement() {\r\n        if (!this.statusBarElement) {\r\n            this.statusBarElement = this.addStatusBarItem();\r\n        }\r\n        return this.statusBarElement;\r\n    }\r\n\r\n    /**\r\n     * Creates an icon button that when clicked, will send a request to terminate shell command execution intermittently.\r\n     *\r\n     * @param containerElement\r\n     * @param processTerminator A callback that will actually terminate the shell command execution process.\r\n     */\r\n    public createRequestTerminatingButton(containerElement: HTMLElement, processTerminator: () => void) {\r\n        const button = containerElement.createEl('a', {\r\n            prepend: true,\r\n            attr: {\r\n                \"aria-label\": \"Request to terminate the process\",\r\n                class: \"SC-icon-terminate-process\",\r\n            },\r\n        });\r\n        setIcon(button, \"power\");\r\n        button.onclick = (event) => {\r\n            processTerminator();\r\n            event.preventDefault();\r\n            event.stopPropagation();\r\n        };\r\n    }\r\n}\r\n\r\n\r\n"],"names":["Modal","Setting","FileSystemAdapter","path","platform","MarkdownView","normalizePath","shell","clipboard","EOL","Notice","moment","getAllTags","TFolder","TFile","Platform","fs","child_process","spawn","this","setIcon","parseYaml","ItemView","PluginSettingTab","Plugin"],"mappings":"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"}