765 lines
61 KiB
JavaScript
765 lines
61 KiB
JavaScript
'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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"}
|