'use strict';

var obsidian = require('obsidian');

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);
}

/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

function __awaiter(thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

/** Calculate a unique SHA-256 hash for the given object */
function calculateHash(val) {
    return __awaiter(this, void 0, void 0, function* () {
        const data = new TextEncoder().encode(JSON.stringify(val));
        /* istanbul ignore if */
        if (typeof crypto !== "undefined") {
            const buffer = yield crypto.subtle.digest("SHA-256", data);
            const raw = Array.from(new Uint8Array(buffer));
            // Convery binary hash to hex
            const hash = raw.map((b) => b.toString(16).padStart(2, "0")).join("");
            return hash;
        }
        else {
            // Use node `crypto` module as fallback when browser subtle crypto does not exist,
            // this primarily exists to allow tests to generate hashes, and will not function if used in the browser context
            const { createHash } = yield Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('crypto')); });
            return createHash("sha256").update(data).digest("hex");
        }
    });
}
/** Unsafe cast method.
 *  Will transform the given type `F` into `T`,
 *      use only when you know this will be valid. */
function ucast(o) {
    return o;
}

var DegreeMode;
(function (DegreeMode) {
    DegreeMode["Radians"] = "RADIANS";
    DegreeMode["Degrees"] = "DEGREES";
})(DegreeMode || (DegreeMode = {}));
var LineStyle;
(function (LineStyle) {
    LineStyle["Solid"] = "SOLID";
    LineStyle["Dashed"] = "DASHED";
    LineStyle["Dotted"] = "DOTTED";
})(LineStyle || (LineStyle = {}));
var PointStyle;
(function (PointStyle) {
    PointStyle["Point"] = "POINT";
    PointStyle["Open"] = "OPEN";
    PointStyle["Cross"] = "CROSS";
})(PointStyle || (PointStyle = {}));
var ColorConstant;
(function (ColorConstant) {
    ColorConstant["Red"] = "#ff0000";
    ColorConstant["Green"] = "#00ff00";
    ColorConstant["Blue"] = "#0000ff";
    ColorConstant["Yellow"] = "#ffff00";
    ColorConstant["Magenta"] = "#ff00ff";
    ColorConstant["Cyan"] = "#00ffff";
    ColorConstant["Purple"] = "#6042a6";
    ColorConstant["Orange"] = "#ffa500";
    ColorConstant["Black"] = "#000000";
    ColorConstant["White"] = "#ffffff";
})(ColorConstant || (ColorConstant = {}));

/** The maximum dimensions of a graph */
const MAX_SIZE = 99999;
const DEFAULT_GRAPH_SETTINGS = {
    width: 600,
    height: 400,
    left: -10,
    right: 10,
    bottom: -7,
    top: 7,
    grid: true,
    degreeMode: DegreeMode.Radians,
    hideAxisNumbers: false,
};
const DEFAULT_GRAPH_WIDTH = Math.abs(DEFAULT_GRAPH_SETTINGS.left) + Math.abs(DEFAULT_GRAPH_SETTINGS.right);
const DEFAULT_GRAPH_HEIGHT = Math.abs(DEFAULT_GRAPH_SETTINGS.bottom) + Math.abs(DEFAULT_GRAPH_SETTINGS.top);
function parseStringToEnum(obj, key) {
    const objKey = Object.keys(obj).find((k) => k.toUpperCase() === key.toUpperCase());
    return objKey ? obj[objKey] : null;
}
function parseColor(value) {
    // If the value is a valid hex colour
    if (value.startsWith("#")) {
        // Ensure the rest of the value is a valid alphanumeric string
        if (/^[0-9a-zA-Z]+$/.test(value.slice(1))) {
            return value;
        }
    }
    // If the value is a valid colour constant
    return parseStringToEnum(ColorConstant, value);
}
class Graph {
    constructor(equations, settings, potentialErrorHint) {
        this.equations = equations;
        this.potentialErrorHint = potentialErrorHint;
        // Adjust bounds (if needed)
        Graph.adjustBounds(settings);
        // Generate hash on the raw equation and setting data,
        //  this means that if we extend the settings with new fields pre-existing graphs will have the same hash
        this._hash = calculateHash({ equations, settings });
        // Apply defaults
        this.settings = Object.assign(Object.assign({}, DEFAULT_GRAPH_SETTINGS), settings);
        // Validate settings
        Graph.validateSettings(this.settings);
        // Apply color override
        if (this.settings.defaultColor) {
            this.equations = this.equations.map((equation) => {
                var _a;
                return (Object.assign({ color: (_a = equation.color) !== null && _a !== void 0 ? _a : this.settings.defaultColor }, equation));
            });
        }
    }
    static parse(source) {
        let potentialErrorHint;
        const split = source.split("---");
        if (split.length > 2) {
            throw new SyntaxError("Too many graph segments, there can only be a singular  '---'");
        }
        // Each (non-blank) line of the equation source contains an equation,
        //  this will always be the last segment
        const equations = split[split.length - 1]
            .split(/\r?\n/g)
            .filter((equation) => equation.trim() !== "")
            .map(Graph.parseEquation)
            .map((result) => {
            if (result.hint) {
                potentialErrorHint = result.hint;
            }
            return result.data;
        });
        // If there is more than one segment then the first one will contain the settings
        const settings = split.length > 1 ? Graph.parseSettings(split[0]) : {};
        return new Graph(equations, settings, potentialErrorHint);
    }
    hash() {
        return __awaiter(this, void 0, void 0, function* () {
            return this._hash;
        });
    }
    static validateSettings(settings) {
        // Check graph is within maximum size
        if ((settings.width && settings.width > MAX_SIZE) || (settings.height && settings.height > MAX_SIZE)) {
            throw new SyntaxError(`Graph size outside of accepted bounds (must be <${MAX_SIZE}x${MAX_SIZE})`);
        }
        // Ensure boundaries are correct
        if (settings.left >= settings.right) {
            throw new SyntaxError(`Right boundary (${settings.right}) must be greater than left boundary (${settings.left})`);
        }
        if (settings.bottom >= settings.top) {
            throw new SyntaxError(`
                Top boundary (${settings.top}) must be greater than bottom boundary (${settings.bottom})
            `);
        }
    }
    static parseEquation(eq) {
        var _a;
        let hint;
        const segments = eq
            .split("|")
            .map((segment) => segment.trim())
            .filter((segment) => segment !== "");
        // First segment is always the equation
        const equation = { equation: ucast(segments.shift()) };
        // The rest of the segments can either be the restriction, style, or color
        //  whilst we recommend putting the restriction first, we accept these in any order.
        for (const segment of segments) {
            const segmentUpperCase = segment.toUpperCase();
            // If this is a `hidden` tag
            if (segmentUpperCase === "HIDDEN") {
                equation.hidden = true;
                continue;
            }
            // If this is a valid style constant
            const style = (_a = parseStringToEnum(LineStyle, segmentUpperCase)) !== null && _a !== void 0 ? _a : parseStringToEnum(PointStyle, segmentUpperCase);
            if (style) {
                if (!equation.style) {
                    equation.style = style;
                }
                else {
                    throw new SyntaxError(`Duplicate style identifiers detected: ${equation.style}, ${segment}`);
                }
                continue;
            }
            // If this is a valid color constant or hex code
            const color = parseColor(segment);
            if (color) {
                if (!equation.color) {
                    equation.color = color;
                }
                else {
                    throw new SyntaxError(`Duplicate color identifiers detected, each equation may only contain a single color code.`);
                }
                continue;
            }
            // If this is a valid label string
            if (segmentUpperCase.startsWith("LABEL:")) {
                const label = segment.split(":").slice(1).join(":").trim();
                if (equation.label === undefined) {
                    if (label === "") {
                        throw new SyntaxError(`Equation label must have a value`);
                    }
                    else {
                        equation.label = label;
                    }
                }
                else {
                    throw new SyntaxError(`Duplicate equation labels detected, each equation may only contain a single label.`);
                }
                continue;
            }
            // If this is a valid defult label string
            if (segmentUpperCase === "LABEL") {
                // If we pass an empty string as the label,
                //  Desmos will use the source equation of the point as the label
                equation.label = "";
                continue;
            }
            // If none of the above, assume it is a graph restriction
            if (segment.includes("\\")) {
                // If the restriction included a `\` (the LaTeX control character) then the user may have tried to use the LaTeX syntax in the graph restriction (e.g `\frac{1}{2}`)
                //  Desmos does not allow this but returns a fairly archaic error - "A piecewise expression must have at least one condition."
                const view = document.createElement("span");
                const pre = document.createElement("span");
                pre.innerHTML = "You may have tried to use the LaTeX syntax in the graph restriction (";
                const inner = document.createElement("code");
                inner.innerText = segment;
                const post = document.createElement("span");
                post.innerHTML =
                    "), please use some sort of an alternative (e.g <code>\\frac{1}{2}</code> => <code>1/2</code>) as this is not supported by Desmos.";
                view.appendChild(pre);
                view.appendChild(inner);
                view.appendChild(post);
                hint = { view };
            }
            if (!equation.restrictions) {
                equation.restrictions = [];
            }
            equation.restrictions.push(segment);
        }
        return { data: equation, hint };
    }
    static parseSettings(settings) {
        const graphSettings = {};
        // Settings may be separated by either a newline or semicolon
        settings
            .split(/[;\n]/g)
            .map((setting) => setting.trim())
            .filter((setting) => setting !== "")
            // Extract key-value pairs by splitting on the `=` in each property
            .map((setting) => setting.split("="))
            .forEach((setting) => {
            if (setting.length > 2) {
                throw new SyntaxError(`Too many segments, eaching setting must only contain a maximum of one '=' sign`);
            }
            const key = setting[0].trim();
            const value = setting.length > 1 ? setting[1].trim() : undefined;
            // Prevent duplicate keys
            if (key in graphSettings) {
                throw new SyntaxError(`Duplicate key '${key}' not allowed`);
            }
            const requiresValue = () => {
                if (value === undefined) {
                    throw new SyntaxError(`Field '${key}' must have a value`);
                }
            };
            switch (key) {
                // Boolean fields
                case "hideAxisNumbers":
                case "grid": {
                    if (!value) {
                        graphSettings[key] = true;
                    }
                    else {
                        const lower = value.toLowerCase();
                        if (lower !== "true" && lower !== "false") {
                            throw new SyntaxError(`Field '${key}' requres a boolean value 'true'/'false' (omit a value to default to 'true')`);
                        }
                        graphSettings[key] = value === "true" ? true : false;
                    }
                    break;
                }
                // Integer fields
                case "top":
                case "bottom":
                case "left":
                case "right":
                case "width":
                case "height": {
                    requiresValue();
                    const num = parseFloat(value);
                    if (Number.isNaN(num)) {
                        throw new SyntaxError(`Field '${key}' must have an integer (or decimal) value`);
                    }
                    graphSettings[key] = num;
                    break;
                }
                // DegreeMode field
                case "degreeMode": {
                    requiresValue();
                    const mode = parseStringToEnum(DegreeMode, value);
                    if (mode) {
                        graphSettings.degreeMode = mode;
                    }
                    else {
                        throw new SyntaxError(`Field 'degreeMode' must be either 'radians' or 'degrees'`);
                    }
                    break;
                }
                // Color field
                case "defaultColor": {
                    requiresValue();
                    const color = parseColor(value);
                    if (color) {
                        graphSettings.defaultColor = color;
                    }
                    else {
                        throw new SyntaxError(`Field 'defaultColor' must be either a valid hex code or one of: ${Object.keys(ColorConstant).join(", ")}`);
                    }
                    break;
                }
                default: {
                    throw new SyntaxError(`Unrecognised field: ${key}`);
                }
            }
        });
        return graphSettings;
    }
    /** Dynamically adjust graph boundary if the defaults would cause an invalid graph with the settings supplied by the user,
     *  this will not do anything if the adjustment is not required.
     */
    static adjustBounds(settings) {
        if (settings.left !== undefined &&
            settings.right === undefined &&
            settings.left >= DEFAULT_GRAPH_SETTINGS.right) {
            settings.right = settings.left + DEFAULT_GRAPH_WIDTH;
        }
        if (settings.left === undefined &&
            settings.right !== undefined &&
            settings.right <= DEFAULT_GRAPH_SETTINGS.left) {
            settings.left = settings.right - DEFAULT_GRAPH_WIDTH;
        }
        if (settings.bottom !== undefined &&
            settings.top === undefined &&
            settings.bottom >= DEFAULT_GRAPH_SETTINGS.top) {
            settings.top = settings.bottom + DEFAULT_GRAPH_HEIGHT;
        }
        if (settings.bottom === undefined &&
            settings.top !== undefined &&
            settings.top <= DEFAULT_GRAPH_SETTINGS.bottom) {
            settings.bottom = settings.top - DEFAULT_GRAPH_HEIGHT;
        }
        return settings;
    }
}

function renderError(err, el, extra) {
    const wrapper = document.createElement("div");
    const message = document.createElement("strong");
    message.innerText = "Desmos Graph Error: ";
    wrapper.appendChild(message);
    const ctx = document.createElement("span");
    ctx.innerText = err;
    wrapper.appendChild(ctx);
    if (extra) {
        const messageExtra = document.createElement("strong");
        messageExtra.innerHTML = "<br>Note: ";
        wrapper.appendChild(messageExtra);
        wrapper.appendChild(extra);
    }
    const container = document.createElement("div");
    container.style.padding = "20px";
    container.style.backgroundColor = "#f44336";
    container.style.color = "white";
    container.appendChild(wrapper);
    el.empty();
    el.appendChild(container);
}

var CacheLocation;
(function (CacheLocation) {
    CacheLocation["Memory"] = "Memory";
    CacheLocation["Filesystem"] = "Filesystem";
})(CacheLocation || (CacheLocation = {}));
const DEFAULT_SETTINGS_STATIC = {
    // debounce: 500,
    cache: {
        enabled: true,
        location: CacheLocation.Memory,
    },
};
/** Get the default settings for the given plugin. This simply uses `DEFAULT_SETTINGS_STATIC` and patches the version from the manifest. */
function DEFAULT_SETTINGS(plugin) {
    return Object.assign({ version: plugin.manifest.version }, DEFAULT_SETTINGS_STATIC);
}
/** Attempt to migrate the given settings object to the current structure */
function migrateSettings(plugin, settings) {
    // todo (there is currently only one version of the settings interface)
    return settings;
}
class SettingsTab extends obsidian.PluginSettingTab {
    constructor(app, plugin) {
        super(app, plugin);
        this.plugin = plugin;
    }
    display() {
        const { containerEl } = this;
        containerEl.empty();
        // new Setting(containerEl)
        //     .setName("Debounce Time (ms)")
        //     .setDesc(
        //         "How long to wait after a keypress to render the graph (set to 0 to disable, requires restart to take effect)"
        //     )
        //     .addText((text) =>
        //         text.setValue(this.plugin.settings.debounce.toString()).onChange(async (value) => {
        //             const val = parseInt(value);
        //             this.plugin.settings.debounce =
        //                 Number.isNaN(val) || val < 0 ? DEFAULT_SETTINGS_STATIC.debounce : val;
        //             await this.plugin.saveSettings();
        //         })
        //     );
        new obsidian.Setting(containerEl)
            .setName("Cache")
            .setDesc("Whether to cache the rendered graphs")
            .addToggle((toggle) => toggle.setValue(this.plugin.settings.cache.enabled).onChange((value) => __awaiter(this, void 0, void 0, function* () {
            this.plugin.settings.cache.enabled = value;
            yield this.plugin.saveSettings();
            // Reset the display so the new state can render
            this.display();
        })));
        if (this.plugin.settings.cache.enabled) {
            new obsidian.Setting(containerEl)
                .setName("Cache location")
                .setDesc("Set the location to cache rendered graphs (note that memory caching is not persistent)")
                .addDropdown((dropdown) => dropdown
                .addOption(CacheLocation.Memory, "Memory")
                .addOption(CacheLocation.Filesystem, "Filesystem")
                .setValue(this.plugin.settings.cache.location)
                .onChange((value) => __awaiter(this, void 0, void 0, function* () {
                this.plugin.settings.cache.location = value;
                yield this.plugin.saveSettings();
                // Reset the display so the new state can render
                this.display();
            })));
            if (this.plugin.settings.cache.location === CacheLocation.Filesystem) {
                new obsidian.Setting(containerEl)
                    .setName("Cache Directory")
                    .setDesc(`The directory to save cached graphs in, relative to the vault root (technical note: the graphs will be saved as \`desmos-graph-<hash>.svg\` where the name is a SHA-256 hash of the graph source). Also note that a lot of junk will be saved to this folder, you have been warned.`)
                    .addText((text) => {
                    var _a;
                    text.setValue((_a = this.plugin.settings.cache.directory) !== null && _a !== void 0 ? _a : "").onChange((value) => __awaiter(this, void 0, void 0, function* () {
                        this.plugin.settings.cache.directory = value;
                        yield this.plugin.saveSettings();
                    }));
                });
            }
        }
    }
}

/** Parse an SVG into a DOM element */
function parseSVG(svg) {
    return new DOMParser().parseFromString(svg, "image/svg+xml").documentElement;
}
class Renderer {
    constructor(plugin) {
        /** The set of graphs we are currently rendering, mapped by their hash */
        this.rendering = new Map();
        this.plugin = plugin;
        this.active = false;
    }
    activate() {
        if (!this.active) {
            window.addEventListener("message", this.handler.bind(this));
            this.active = true;
        }
    }
    deactivate() {
        if (this.active) {
            window.removeEventListener("message", this.handler.bind(this));
            this.active = false;
        }
    }
    render(graph, el) {
        return __awaiter(this, void 0, void 0, function* () {
            const plugin = this.plugin;
            const settings = plugin.settings;
            const equations = graph.equations;
            const graphSettings = graph.settings;
            const hash = yield graph.hash();
            let cacheFile;
            // If this graph is in the cache then fetch it
            if (settings.cache.enabled) {
                if (settings.cache.location === CacheLocation.Memory && hash in plugin.graphCache) {
                    const data = plugin.graphCache[hash];
                    el.appendChild(parseSVG(data));
                    return;
                }
                else if (settings.cache.location === CacheLocation.Filesystem && settings.cache.directory) {
                    const adapter = plugin.app.vault.adapter;
                    cacheFile = obsidian.normalizePath(`${settings.cache.directory}/desmos-graph-${hash}.svg`);
                    // If this graph is in the cache
                    if (yield adapter.exists(cacheFile)) {
                        const data = yield adapter.read(cacheFile);
                        el.appendChild(parseSVG(data));
                        return;
                    }
                }
            }
            // Parse equations into a series of Desmos expressions
            const expressions = [];
            for (const equation of equations) {
                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                const expression = {
                    color: equation.color,
                    label: equation.label,
                    showLabel: equation.label !== undefined,
                };
                if (equation.restrictions) {
                    const restriction = equation.restrictions
                        .map((restriction) => `{${restriction}}`
                        // Escape chars
                        .replaceAll("{", String.raw `\{`)
                        .replaceAll("}", String.raw `\}`)
                        .replaceAll("<=", String.raw `\leq `)
                        .replaceAll(">=", String.raw `\geq `)
                        .replaceAll("<", String.raw `\le `)
                        .replaceAll(">", String.raw `\ge `))
                        .join("");
                    expression.latex = `${equation.equation}${restriction}`;
                }
                else {
                    expression.latex = equation.equation;
                }
                if (equation.style) {
                    if (Object.values(LineStyle).includes(ucast(equation.style))) {
                        expression.lineStyle = equation.style;
                    }
                    else if (Object.values(PointStyle).includes(ucast(equation.style))) {
                        expression.pointStyle = equation.style;
                    }
                }
                // Calling JSON.stringify twice allows us to escape the strings as well,
                //  meaning we can embed it directly into the calculator to undo the first stringification without parsing
                expressions.push(`calculator.setExpression(JSON.parse(${JSON.stringify(JSON.stringify(expression))}));`);
            }
            // Because of the electron sandboxing we have to do this inside an iframe (and regardless this is safer),
            //   otherwise we can't include the desmos API (although it would be nice if they had a REST API of some sort)
            // Interestingly enough, this script functions perfectly fine fully offline - so we could include a vendored copy if need be
            //   (the script gets cached by electron the first time it's used so this isn't a particularly high priority)
            const htmlHead = `<script src="https://www.desmos.com/api/v1.6/calculator.js?apiKey=dcb31709b452b1cf9dc26972add0fda6"></script>`;
            const htmlBody = `
            <div id="calculator-${hash}" style="width: ${graphSettings.width}px; height: ${graphSettings.height}px;"></div>
            <script>
                const options = {
                    settingsMenu: false,
                    expressions: false,
                    lockViewPort: true,
                    zoomButtons: false,
                    trace: false,
                    xAxisNumbers: ${!graphSettings.hideAxisNumbers},
                    yAxisNumbers: ${!graphSettings.hideAxisNumbers},
                    showGrid: ${graphSettings.grid},
                    // Desmos takes a value of 'false' for radians and 'true' for degrees
                    degreeMode: ${graphSettings.degreeMode === DegreeMode.Degrees},
                };

                const calculator = Desmos.GraphingCalculator(document.getElementById("calculator-${hash}"), options);
                calculator.setMathBounds({
                    left: ${graphSettings.left},
                    right: ${graphSettings.right},
                    top: ${graphSettings.top},
                    bottom: ${graphSettings.bottom},
                });

                ${expressions.join("\n")}

                // Desmos returns an error if we try to observe the expressions without any defined
                if (${expressions.length > 0}) {
                    calculator.observe("expressionAnalysis", () => {
                        for (const id in calculator.expressionAnalysis) {
                            const analysis = calculator.expressionAnalysis[id];
                            if (analysis.isError) {
                                parent.postMessage({ t: "desmos-graph", d: "error", o: "${window.origin}", data: analysis.errorMessage, hash: "${hash}" }, "${window.origin}");
                            }
                        }
                    });
                }

                calculator.asyncScreenshot({ showLabels: true, format: "svg" }, (data) => {
                    document.body.innerHTML = "";
                    parent.postMessage({ t: "desmos-graph", d: "render", o: "${window.origin}", data, hash: "${hash}" }, "${window.origin}");
                });
            </script>
        `;
            const htmlSrc = `<html><head>${htmlHead}</head><body>${htmlBody}</body>`;
            const iframe = document.createElement("iframe");
            iframe.sandbox.add("allow-scripts"); // enable sandbox mode - this prevents any xss exploits from an untrusted source in the frame (and prevents it from accessing the parent)
            iframe.width = graphSettings.width.toString();
            iframe.height = graphSettings.height.toString();
            iframe.className = "desmos-graph";
            iframe.style.border = "none";
            iframe.scrolling = "no"; // fixme use a non-depreciated function
            iframe.srcdoc = htmlSrc;
            // iframe.style.display = "none"; // fixme hiding the iframe breaks the positioning
            el.appendChild(iframe);
            return new Promise((resolve) => this.rendering.set(hash, { graph, el, resolve, cacheFile }));
        });
    }
    handler(message) {
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            if (message.data.o === window.origin && message.data.t === "desmos-graph") {
                const state = this.rendering.get(message.data.hash);
                if (state) {
                    const { graph, el, resolve, cacheFile } = state;
                    el.empty();
                    if (message.data.d === "error") {
                        renderError(message.data.data, el, (_a = graph.potentialErrorHint) === null || _a === void 0 ? void 0 : _a.view);
                        resolve(); // let caller know we are done rendering
                    }
                    else if (message.data.d === "render") {
                        const { data } = message.data;
                        const node = parseSVG(data);
                        node.setAttribute("class", "desmos-graph");
                        el.appendChild(node);
                        resolve(); // let caller know we are done rendering
                        const plugin = this.plugin;
                        const settings = plugin.settings;
                        const hash = yield graph.hash();
                        if (settings.cache.enabled) {
                            if (settings.cache.location === CacheLocation.Memory) {
                                plugin.graphCache[hash] = data;
                            }
                            else if (settings.cache.location === CacheLocation.Filesystem) {
                                const adapter = plugin.app.vault.adapter;
                                if (cacheFile && settings.cache.directory) {
                                    if (yield adapter.exists(settings.cache.directory)) {
                                        yield adapter.write(cacheFile, data);
                                    }
                                    else {
                                        new obsidian.Notice(`desmos-graph: target cache directory '${settings.cache.directory}' does not exist, skipping cache`, 10000);
                                    }
                                }
                                else {
                                    new obsidian.Notice(`desmos-graph: filesystem caching enabled but no cache directory set, skipping cache`, 10000);
                                }
                            }
                        }
                    }
                    this.rendering.delete(message.data.hash);
                }
                else {
                    // do nothing if graph is not in render list (this should not happen)
                    console.warn(`Got graph not in render list, this is probably a bug - ${JSON.stringify(this.rendering)}`);
                }
            }
        });
    }
}

class Desmos extends obsidian.Plugin {
    constructor() {
        super(...arguments);
        /** Helper for in-memory graph caching */
        this.graphCache = {};
    }
    onload() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.loadSettings();
            this.renderer = new Renderer(this);
            this.renderer.activate();
            this.addSettingTab(new SettingsTab(this.app, this));
            this.registerMarkdownCodeBlockProcessor("desmos-graph", (source, el) => __awaiter(this, void 0, void 0, function* () {
                try {
                    const graph = Graph.parse(source);
                    yield this.renderer.render(graph, el);
                }
                catch (err) {
                    if (err instanceof Error) {
                        renderError(err.message, el);
                    }
                    else if (typeof err === "string") {
                        renderError(err, el);
                    }
                    else {
                        renderError("Unexpected error - see console for debug log", el);
                        console.error(err);
                    }
                }
            }));
        });
    }
    unload() {
        return __awaiter(this, void 0, void 0, function* () {
            this.renderer.deactivate();
        });
    }
    loadSettings() {
        return __awaiter(this, void 0, void 0, function* () {
            let settings = yield this.loadData();
            if (!settings) {
                settings = DEFAULT_SETTINGS(this);
            }
            if (settings.version !== this.manifest.version) {
                settings = migrateSettings(this, settings);
            }
            this.settings = settings;
        });
    }
    saveSettings() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.saveData(this.settings);
        });
    }
}

module.exports = Desmos;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","src/utils.ts","src/graph/interface.ts","src/graph/parser.ts","src/error.ts","src/settings.ts","src/renderer.ts","src/main.ts"],"sourcesContent":null,"names":["PluginSettingTab","Setting","normalizePath","Notice","Plugin"],"mappings":"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"}