1242 lines
173 KiB
JavaScript
1242 lines
173 KiB
JavaScript
'use strict';
|
|
|
|
var obsidian = require('obsidian');
|
|
|
|
const modifiers = /^(CommandOrControl|CmdOrCtrl|Command|Cmd|Control|Ctrl|AltGr|Option|Alt|Shift|Super)/i;
|
|
const keyCodes = /^(Plus|Space|Tab|Backspace|Delete|Insert|Return|Enter|Up|Down|Left|Right|Home|End|PageUp|PageDown|Escape|Esc|VolumeUp|VolumeDown|VolumeMute|MediaNextTrack|MediaPreviousTrack|MediaStop|MediaPlayPause|PrintScreen|F24|F23|F22|F21|F20|F19|F18|F17|F16|F15|F14|F13|F12|F11|F10|F9|F8|F7|F6|F5|F4|F3|F2|F1|[0-9A-Z)!@#$%^&*(:+<_>?~{|}";=,\-./`[\\\]'])/i;
|
|
const UNSUPPORTED = {};
|
|
|
|
function _command(accelerator, event, modifier) {
|
|
if (process.platform !== 'darwin') {
|
|
return UNSUPPORTED;
|
|
}
|
|
|
|
if (event.metaKey) {
|
|
throw new Error('Double `Command` modifier specified.');
|
|
}
|
|
|
|
return {
|
|
event: Object.assign({}, event, {metaKey: true}),
|
|
accelerator: accelerator.slice(modifier.length)
|
|
};
|
|
}
|
|
|
|
function _super(accelerator, event, modifier) {
|
|
if (event.metaKey) {
|
|
throw new Error('Double `Super` modifier specified.');
|
|
}
|
|
|
|
return {
|
|
event: Object.assign({}, event, {metaKey: true}),
|
|
accelerator: accelerator.slice(modifier.length)
|
|
};
|
|
}
|
|
|
|
function _commandorcontrol(accelerator, event, modifier) {
|
|
if (process.platform === 'darwin') {
|
|
if (event.metaKey) {
|
|
throw new Error('Double `Command` modifier specified.');
|
|
}
|
|
|
|
return {
|
|
event: Object.assign({}, event, {metaKey: true}),
|
|
accelerator: accelerator.slice(modifier.length)
|
|
};
|
|
}
|
|
|
|
if (event.ctrlKey) {
|
|
throw new Error('Double `Control` modifier specified.');
|
|
}
|
|
|
|
return {
|
|
event: Object.assign({}, event, {ctrlKey: true}),
|
|
accelerator: accelerator.slice(modifier.length)
|
|
};
|
|
}
|
|
|
|
function _alt(accelerator, event, modifier) {
|
|
if (modifier === 'option' && process.platform !== 'darwin') {
|
|
return UNSUPPORTED;
|
|
}
|
|
|
|
if (event.altKey) {
|
|
throw new Error('Double `Alt` modifier specified.');
|
|
}
|
|
|
|
return {
|
|
event: Object.assign({}, event, {altKey: true}),
|
|
accelerator: accelerator.slice(modifier.length)
|
|
};
|
|
}
|
|
|
|
function _shift(accelerator, event, modifier) {
|
|
if (event.shiftKey) {
|
|
throw new Error('Double `Shift` modifier specified.');
|
|
}
|
|
|
|
return {
|
|
event: Object.assign({}, event, {shiftKey: true}),
|
|
accelerator: accelerator.slice(modifier.length)
|
|
};
|
|
}
|
|
|
|
function _control(accelerator, event, modifier) {
|
|
if (event.ctrlKey) {
|
|
throw new Error('Double `Control` modifier specified.');
|
|
}
|
|
|
|
return {
|
|
event: Object.assign({}, event, {ctrlKey: true}),
|
|
accelerator: accelerator.slice(modifier.length)
|
|
};
|
|
}
|
|
|
|
function reduceModifier({accelerator, event}, modifier) {
|
|
switch (modifier) {
|
|
case 'command':
|
|
case 'cmd': {
|
|
return _command(accelerator, event, modifier);
|
|
}
|
|
|
|
case 'super': {
|
|
return _super(accelerator, event, modifier);
|
|
}
|
|
|
|
case 'control':
|
|
case 'ctrl': {
|
|
return _control(accelerator, event, modifier);
|
|
}
|
|
|
|
case 'commandorcontrol':
|
|
case 'cmdorctrl': {
|
|
return _commandorcontrol(accelerator, event, modifier);
|
|
}
|
|
|
|
case 'option':
|
|
case 'altgr':
|
|
case 'alt': {
|
|
return _alt(accelerator, event, modifier);
|
|
}
|
|
|
|
case 'shift': {
|
|
return _shift(accelerator, event, modifier);
|
|
}
|
|
|
|
default:
|
|
console.error(modifier);
|
|
}
|
|
}
|
|
|
|
function reducePlus({accelerator, event}) {
|
|
return {
|
|
event,
|
|
accelerator: accelerator.trim().slice(1)
|
|
};
|
|
}
|
|
|
|
const virtualKeyCodes = {
|
|
0: 'Digit0',
|
|
1: 'Digit1',
|
|
2: 'Digit2',
|
|
3: 'Digit3',
|
|
4: 'Digit4',
|
|
5: 'Digit5',
|
|
6: 'Digit6',
|
|
7: 'Digit7',
|
|
8: 'Digit8',
|
|
9: 'Digit9',
|
|
'-': 'Minus',
|
|
'=': 'Equal',
|
|
Q: 'KeyQ',
|
|
W: 'KeyW',
|
|
E: 'KeyE',
|
|
R: 'KeyR',
|
|
T: 'KeyT',
|
|
Y: 'KeyY',
|
|
U: 'KeyU',
|
|
I: 'KeyI',
|
|
O: 'KeyO',
|
|
P: 'KeyP',
|
|
'[': 'BracketLeft',
|
|
']': 'BracketRight',
|
|
A: 'KeyA',
|
|
S: 'KeyS',
|
|
D: 'KeyD',
|
|
F: 'KeyF',
|
|
G: 'KeyG',
|
|
H: 'KeyH',
|
|
J: 'KeyJ',
|
|
K: 'KeyK',
|
|
L: 'KeyL',
|
|
';': 'Semicolon',
|
|
'\'': 'Quote',
|
|
'`': 'Backquote',
|
|
'/': 'Backslash',
|
|
Z: 'KeyZ',
|
|
X: 'KeyX',
|
|
C: 'KeyC',
|
|
V: 'KeyV',
|
|
B: 'KeyB',
|
|
N: 'KeyN',
|
|
M: 'KeyM',
|
|
',': 'Comma',
|
|
'.': 'Period',
|
|
'\\': 'Slash',
|
|
' ': 'Space'
|
|
};
|
|
|
|
function reduceKey({accelerator, event}, key) {
|
|
if (key.length > 1 || event.key) {
|
|
throw new Error(`Unvalid keycode \`${key}\`.`);
|
|
}
|
|
|
|
const code =
|
|
key.toUpperCase() in virtualKeyCodes ?
|
|
virtualKeyCodes[key.toUpperCase()] :
|
|
null;
|
|
|
|
return {
|
|
event: Object.assign({}, event, {key}, code ? {code} : null),
|
|
accelerator: accelerator.trim().slice(key.length)
|
|
};
|
|
}
|
|
|
|
const domKeys = Object.assign(Object.create(null), {
|
|
plus: 'Add',
|
|
space: 'Space',
|
|
tab: 'Tab',
|
|
backspace: 'Backspace',
|
|
delete: 'Delete',
|
|
insert: 'Insert',
|
|
return: 'Return',
|
|
enter: 'Return',
|
|
up: 'ArrowUp',
|
|
down: 'ArrowDown',
|
|
left: 'ArrowLeft',
|
|
right: 'ArrowRight',
|
|
home: 'Home',
|
|
end: 'End',
|
|
pageup: 'PageUp',
|
|
pagedown: 'PageDown',
|
|
escape: 'Escape',
|
|
esc: 'Escape',
|
|
volumeup: 'AudioVolumeUp',
|
|
volumedown: 'AudioVolumeDown',
|
|
volumemute: 'AudioVolumeMute',
|
|
medianexttrack: 'MediaTrackNext',
|
|
mediaprevioustrack: 'MediaTrackPrevious',
|
|
mediastop: 'MediaStop',
|
|
mediaplaypause: 'MediaPlayPause',
|
|
printscreen: 'PrintScreen'
|
|
});
|
|
|
|
// Add function keys
|
|
for (let i = 1; i <= 24; i++) {
|
|
domKeys[`f${i}`] = `F${i}`;
|
|
}
|
|
|
|
function reduceCode({accelerator, event}, {code, key}) {
|
|
if (event.code) {
|
|
throw new Error(`Duplicated keycode \`${key}\`.`);
|
|
}
|
|
|
|
return {
|
|
event: Object.assign({}, event, {key}, code ? {code} : null),
|
|
accelerator: accelerator.trim().slice((key && key.length) || 0)
|
|
};
|
|
}
|
|
|
|
/**
|
|
* This function transform an Electron Accelerator string into
|
|
* a DOM KeyboardEvent object.
|
|
*
|
|
* @param {string} accelerator an Electron Accelerator string, e.g. `Ctrl+C` or `Shift+Space`.
|
|
* @return {object} a DOM KeyboardEvent object derivate from the `accelerator` argument.
|
|
*/
|
|
function toKeyEvent(accelerator) {
|
|
let state = {accelerator, event: {}};
|
|
while (state.accelerator !== '') {
|
|
const modifierMatch = state.accelerator.match(modifiers);
|
|
if (modifierMatch) {
|
|
const modifier = modifierMatch[0].toLowerCase();
|
|
state = reduceModifier(state, modifier);
|
|
if (state === UNSUPPORTED) {
|
|
return {unsupportedKeyForPlatform: true};
|
|
}
|
|
} else if (state.accelerator.trim()[0] === '+') {
|
|
state = reducePlus(state);
|
|
} else {
|
|
const codeMatch = state.accelerator.match(keyCodes);
|
|
if (codeMatch) {
|
|
const code = codeMatch[0].toLowerCase();
|
|
if (code in domKeys) {
|
|
state = reduceCode(state, {
|
|
code: domKeys[code],
|
|
key: code
|
|
});
|
|
} else {
|
|
state = reduceKey(state, code);
|
|
}
|
|
} else {
|
|
throw new Error(`Unvalid accelerator: "${state.accelerator}"`);
|
|
}
|
|
}
|
|
}
|
|
|
|
return state.event;
|
|
}
|
|
|
|
var keyboardeventFromElectronAccelerator = {
|
|
UNSUPPORTED,
|
|
reduceModifier,
|
|
reducePlus,
|
|
reduceKey,
|
|
reduceCode,
|
|
toKeyEvent
|
|
};
|
|
|
|
/**
|
|
* Follows the link under the cursor, temporarily moving the cursor if necessary for follow-link to
|
|
* work (i.e. if the cursor is on a starting square bracket).
|
|
*/
|
|
const followLinkUnderCursor = (vimrcPlugin) => {
|
|
const obsidianEditor = vimrcPlugin.getActiveObsidianEditor();
|
|
const { line, ch } = obsidianEditor.getCursor();
|
|
const firstTwoChars = obsidianEditor.getRange({ line, ch }, { line, ch: ch + 2 });
|
|
let numCharsMoved = 0;
|
|
for (const char of firstTwoChars) {
|
|
if (char === "[") {
|
|
obsidianEditor.exec("goRight");
|
|
numCharsMoved++;
|
|
}
|
|
}
|
|
vimrcPlugin.executeObsidianCommand("editor:follow-link");
|
|
// Move the cursor back to where it was
|
|
for (let i = 0; i < numCharsMoved; i++) {
|
|
obsidianEditor.exec("goLeft");
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Moves the cursor down `repeat` lines, skipping over folded sections.
|
|
*/
|
|
const moveDownSkippingFolds = (vimrcPlugin, cm, { repeat }) => {
|
|
moveSkippingFolds(vimrcPlugin, repeat, "down");
|
|
};
|
|
/**
|
|
* Moves the cursor up `repeat` lines, skipping over folded sections.
|
|
*/
|
|
const moveUpSkippingFolds = (vimrcPlugin, cm, { repeat }) => {
|
|
moveSkippingFolds(vimrcPlugin, repeat, "up");
|
|
};
|
|
function moveSkippingFolds(vimrcPlugin, repeat, direction) {
|
|
const obsidianEditor = vimrcPlugin.getActiveObsidianEditor();
|
|
let { line: oldLine, ch: oldCh } = obsidianEditor.getCursor();
|
|
const commandName = direction === "up" ? "goUp" : "goDown";
|
|
for (let i = 0; i < repeat; i++) {
|
|
obsidianEditor.exec(commandName);
|
|
const { line: newLine, ch: newCh } = obsidianEditor.getCursor();
|
|
if (newLine === oldLine && newCh === oldCh) {
|
|
// Going in the specified direction doesn't do anything anymore, stop now
|
|
return;
|
|
}
|
|
[oldLine, oldCh] = [newLine, newCh];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the position of the repeat-th instance of a pattern from a given cursor position, in the
|
|
* given direction; looping to the other end of the document when reaching one end. Returns the
|
|
* original cursor position if no match is found.
|
|
*
|
|
* Under the hood, to avoid repeated loops of the document: we get all matches at once, order them
|
|
* according to `direction` and `cursorPosition`, and use modulo arithmetic to return the
|
|
* appropriate match.
|
|
*
|
|
* @param cm The CodeMirror editor instance.
|
|
* @param cursorPosition The current cursor position.
|
|
* @param repeat The number of times to repeat the jump (e.g. 1 to jump to the very next match). Is
|
|
* modulo-ed for efficiency.
|
|
* @param regex The regex pattern to jump to.
|
|
* @param filterMatch Optional filter function to run on the regex matches. Return false to ignore
|
|
* a given match.
|
|
* @param direction The direction to jump in.
|
|
*/
|
|
function jumpToPattern({ cm, cursorPosition, repeat, regex, filterMatch = () => true, direction, }) {
|
|
const content = cm.getValue();
|
|
const cursorIdx = cm.indexFromPos(cursorPosition);
|
|
const orderedMatches = getOrderedMatches({ content, regex, cursorIdx, filterMatch, direction });
|
|
const effectiveRepeat = (repeat % orderedMatches.length) || orderedMatches.length;
|
|
const matchIdx = orderedMatches[effectiveRepeat - 1]?.index;
|
|
if (matchIdx === undefined) {
|
|
return cursorPosition;
|
|
}
|
|
const newCursorPosition = cm.posFromIndex(matchIdx);
|
|
return newCursorPosition;
|
|
}
|
|
/**
|
|
* Returns an ordered array of all matches of a regex in a string in the given direction from the
|
|
* cursor index (looping around to the other end of the document when reaching one end).
|
|
*/
|
|
function getOrderedMatches({ content, regex, cursorIdx, filterMatch, direction, }) {
|
|
const { previousMatches, currentMatches, nextMatches } = getAndGroupMatches(content, regex, cursorIdx, filterMatch);
|
|
if (direction === "next") {
|
|
return [...nextMatches, ...previousMatches, ...currentMatches];
|
|
}
|
|
return [
|
|
...previousMatches.reverse(),
|
|
...nextMatches.reverse(),
|
|
...currentMatches.reverse(),
|
|
];
|
|
}
|
|
/**
|
|
* Finds all matches of a regex in a string and groups them by their positions relative to the
|
|
* cursor.
|
|
*/
|
|
function getAndGroupMatches(content, regex, cursorIdx, filterMatch) {
|
|
const globalRegex = makeGlobalRegex(regex);
|
|
const allMatches = [...content.matchAll(globalRegex)].filter(filterMatch);
|
|
const previousMatches = allMatches.filter((match) => match.index < cursorIdx && !isWithinMatch(match, cursorIdx));
|
|
const currentMatches = allMatches.filter((match) => isWithinMatch(match, cursorIdx));
|
|
const nextMatches = allMatches.filter((match) => match.index > cursorIdx);
|
|
return { previousMatches, currentMatches, nextMatches };
|
|
}
|
|
function makeGlobalRegex(regex) {
|
|
const globalFlags = getGlobalFlags(regex);
|
|
return new RegExp(regex.source, globalFlags);
|
|
}
|
|
function getGlobalFlags(regex) {
|
|
const { flags } = regex;
|
|
return flags.includes("g") ? flags : `${flags}g`;
|
|
}
|
|
function isWithinMatch(match, index) {
|
|
return match.index <= index && index < match.index + match[0].length;
|
|
}
|
|
|
|
/** Naive Regex for a Markdown heading (H1 through H6). "Naive" because it does not account for
|
|
* whether the match is within a codeblock (e.g. it could be a Python comment, not a heading).
|
|
*/
|
|
const NAIVE_HEADING_REGEX = /^#{1,6} /gm;
|
|
/** Regex for a Markdown fenced codeblock, which begins with some number >=3 of backticks at the
|
|
* start of a line. It either ends on the nearest future line that starts with at least as many
|
|
* backticks (\1 back-reference), or extends to the end of the string if no such future line exists.
|
|
*/
|
|
const FENCED_CODEBLOCK_REGEX = /(^```+)(.*?^\1|.*)/gms;
|
|
/**
|
|
* Jumps to the repeat-th next heading.
|
|
*/
|
|
const jumpToNextHeading = (cm, cursorPosition, { repeat }) => {
|
|
return jumpToHeading({ cm, cursorPosition, repeat, direction: "next" });
|
|
};
|
|
/**
|
|
* Jumps to the repeat-th previous heading.
|
|
*/
|
|
const jumpToPreviousHeading = (cm, cursorPosition, { repeat }) => {
|
|
return jumpToHeading({ cm, cursorPosition, repeat, direction: "previous" });
|
|
};
|
|
/**
|
|
* Jumps to the repeat-th heading in the given direction.
|
|
*
|
|
* Under the hood, we use the naive heading regex to find all headings, and then filter out those
|
|
* that are within codeblocks. `codeblockMatches` is passed in a closure to avoid repeated
|
|
* computation.
|
|
*/
|
|
function jumpToHeading({ cm, cursorPosition, repeat, direction, }) {
|
|
const codeblockMatches = findAllCodeblocks(cm);
|
|
const filterMatch = (match) => !isMatchWithinCodeblock(match, codeblockMatches);
|
|
return jumpToPattern({
|
|
cm,
|
|
cursorPosition,
|
|
repeat,
|
|
regex: NAIVE_HEADING_REGEX,
|
|
filterMatch,
|
|
direction,
|
|
});
|
|
}
|
|
function findAllCodeblocks(cm) {
|
|
const content = cm.getValue();
|
|
return [...content.matchAll(FENCED_CODEBLOCK_REGEX)];
|
|
}
|
|
function isMatchWithinCodeblock(match, codeblockMatches) {
|
|
return codeblockMatches.some((codeblockMatch) => isWithinMatch(codeblockMatch, match.index));
|
|
}
|
|
|
|
const WIKILINK_REGEX_STRING = "\\[\\[.*?\\]\\]";
|
|
const MARKDOWN_LINK_REGEX_STRING = "\\[.*?\\]\\(.*?\\)";
|
|
const URL_REGEX_STRING = "\\w+://\\S+";
|
|
/**
|
|
* Regex for a link (which can be a wikilink, a markdown link, or a standalone URL).
|
|
*/
|
|
const LINK_REGEX_STRING = `${WIKILINK_REGEX_STRING}|${MARKDOWN_LINK_REGEX_STRING}|${URL_REGEX_STRING}`;
|
|
const LINK_REGEX = new RegExp(LINK_REGEX_STRING, "g");
|
|
/**
|
|
* Jumps to the repeat-th next link.
|
|
*
|
|
* Note that `jumpToPattern` uses `String.matchAll`, which internally updates `lastIndex` after each
|
|
* match; and that `LINK_REGEX` matches wikilinks / markdown links first. So, this won't catch
|
|
* non-standalone URLs (e.g. the URL in a markdown link). This should be a good thing in most cases;
|
|
* otherwise it could be tedious (as a user) for each markdown link to contain two jumpable spots.
|
|
*/
|
|
const jumpToNextLink = (cm, cursorPosition, { repeat }) => {
|
|
return jumpToPattern({
|
|
cm,
|
|
cursorPosition,
|
|
repeat,
|
|
regex: LINK_REGEX,
|
|
direction: "next",
|
|
});
|
|
};
|
|
/**
|
|
* Jumps to the repeat-th previous link.
|
|
*/
|
|
const jumpToPreviousLink = (cm, cursorPosition, { repeat }) => {
|
|
return jumpToPattern({
|
|
cm,
|
|
cursorPosition,
|
|
repeat,
|
|
regex: LINK_REGEX,
|
|
direction: "previous",
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Utility types and functions for defining Obsidian-specific Vim commands.
|
|
*/
|
|
function defineAndMapObsidianVimMotion(vimObject, motionFn, mapping) {
|
|
vimObject.defineMotion(motionFn.name, motionFn);
|
|
vimObject.mapCommand(mapping, "motion", motionFn.name, undefined, {});
|
|
}
|
|
function defineAndMapObsidianVimAction(vimObject, vimrcPlugin, obsidianActionFn, mapping) {
|
|
vimObject.defineAction(obsidianActionFn.name, (cm, actionArgs) => {
|
|
obsidianActionFn(vimrcPlugin, cm, actionArgs);
|
|
});
|
|
vimObject.mapCommand(mapping, "action", obsidianActionFn.name, undefined, {});
|
|
}
|
|
|
|
const DEFAULT_SETTINGS = {
|
|
vimrcFileName: ".obsidian.vimrc",
|
|
displayChord: false,
|
|
displayVimMode: false,
|
|
fixedNormalModeLayout: false,
|
|
capturedKeyboardMap: {},
|
|
supportJsCommands: false,
|
|
vimStatusPromptMap: {
|
|
normal: '🟢',
|
|
insert: '🟠',
|
|
visual: '🟡',
|
|
replace: '🔴',
|
|
},
|
|
};
|
|
const vimStatusPromptClass = "vimrc-support-vim-mode";
|
|
// NOTE: to future maintainers, please make sure all mapping commands are included in this array.
|
|
const mappingCommands = [
|
|
"map",
|
|
"nmap",
|
|
"noremap",
|
|
"iunmap",
|
|
"nunmap",
|
|
"vunmap",
|
|
];
|
|
function sleep(ms) {
|
|
return new Promise(resolve => setTimeout(resolve, ms));
|
|
}
|
|
class VimrcPlugin extends obsidian.Plugin {
|
|
constructor() {
|
|
super(...arguments);
|
|
this.codeMirrorVimObject = null;
|
|
this.initialized = false;
|
|
this.lastYankBuffer = [""];
|
|
this.lastSystemClipboard = "";
|
|
this.yankToSystemClipboard = false;
|
|
this.currentKeyChord = [];
|
|
this.vimChordStatusBar = null;
|
|
this.vimStatusBar = null;
|
|
this.currentVimStatus = "normal" /* vimStatus.normal */;
|
|
this.customVimKeybinds = {};
|
|
this.currentSelection = null;
|
|
this.isInsertMode = false;
|
|
this.logVimModeChange = async (cm) => {
|
|
if (!cm)
|
|
return;
|
|
this.isInsertMode = cm.mode === 'insert';
|
|
switch (cm.mode) {
|
|
case "insert":
|
|
this.currentVimStatus = "insert" /* vimStatus.insert */;
|
|
break;
|
|
case "normal":
|
|
this.currentVimStatus = "normal" /* vimStatus.normal */;
|
|
break;
|
|
case "visual":
|
|
this.currentVimStatus = "visual" /* vimStatus.visual */;
|
|
break;
|
|
case "replace":
|
|
this.currentVimStatus = "replace" /* vimStatus.replace */;
|
|
break;
|
|
}
|
|
if (this.settings.displayVimMode)
|
|
this.updateVimStatusBar();
|
|
};
|
|
this.onVimKeypress = async (vimKey) => {
|
|
if (vimKey != "<Esc>") { // TODO figure out what to actually look for to exit commands.
|
|
this.currentKeyChord.push(vimKey);
|
|
if (this.customVimKeybinds[this.currentKeyChord.join("")] != undefined) { // Custom key chord exists.
|
|
this.currentKeyChord = [];
|
|
}
|
|
}
|
|
else {
|
|
this.currentKeyChord = [];
|
|
}
|
|
// Build keychord text
|
|
let tempS = "";
|
|
for (const s of this.currentKeyChord) {
|
|
tempS += " " + s;
|
|
}
|
|
if (tempS != "") {
|
|
tempS += "-";
|
|
}
|
|
this.vimChordStatusBar?.setText(tempS);
|
|
};
|
|
this.onVimCommandDone = async (reason) => {
|
|
this.vimChordStatusBar?.setText("");
|
|
this.currentKeyChord = [];
|
|
};
|
|
this.onKeydown = (ev) => {
|
|
if (this.settings.fixedNormalModeLayout) {
|
|
const keyMap = this.settings.capturedKeyboardMap;
|
|
if (!this.isInsertMode && !ev.shiftKey &&
|
|
ev.code in keyMap && ev.key != keyMap[ev.code]) {
|
|
let view = this.getActiveView();
|
|
if (view) {
|
|
const cmEditor = this.getCodeMirror(view);
|
|
if (cmEditor) {
|
|
this.codeMirrorVimObject.handleKey(cmEditor, keyMap[ev.code], 'mapping');
|
|
}
|
|
}
|
|
ev.preventDefault();
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
updateVimStatusBar() {
|
|
this.vimStatusBar.setText(this.settings.vimStatusPromptMap[this.currentVimStatus]);
|
|
this.vimStatusBar.dataset.vimMode = this.currentVimStatus;
|
|
}
|
|
async captureKeyboardLayout() {
|
|
// This is experimental API and it might break at some point:
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardLayoutMap
|
|
let keyMap = {};
|
|
let layout = await navigator.keyboard.getLayoutMap();
|
|
let doneIterating = new Promise((resolve, reject) => {
|
|
let counted = 0;
|
|
layout.forEach((value, index) => {
|
|
keyMap[index] = value;
|
|
counted += 1;
|
|
if (counted === layout.size)
|
|
resolve();
|
|
});
|
|
});
|
|
await doneIterating;
|
|
new obsidian.Notice('Keyboard layout captured');
|
|
return keyMap;
|
|
}
|
|
async initialize() {
|
|
if (this.initialized)
|
|
return;
|
|
this.codeMirrorVimObject = window.CodeMirrorAdapter?.Vim;
|
|
this.registerYankEvents(activeWindow);
|
|
this.app.workspace.on("window-open", (workspaceWindow, w) => {
|
|
this.registerYankEvents(w);
|
|
});
|
|
this.prepareChordDisplay();
|
|
this.prepareVimModeDisplay();
|
|
// Two events cos
|
|
// this don't trigger on loading/reloading obsidian with note opened
|
|
this.app.workspace.on("active-leaf-change", async () => {
|
|
this.updateSelectionEvent();
|
|
this.updateVimEvents();
|
|
});
|
|
// and this don't trigger on opening same file in new pane
|
|
this.app.workspace.on("file-open", async () => {
|
|
this.updateSelectionEvent();
|
|
this.updateVimEvents();
|
|
});
|
|
this.initialized = true;
|
|
}
|
|
registerYankEvents(win) {
|
|
this.registerDomEvent(win.document, 'click', () => {
|
|
this.captureYankBuffer(win);
|
|
});
|
|
this.registerDomEvent(win.document, 'keyup', () => {
|
|
this.captureYankBuffer(win);
|
|
});
|
|
this.registerDomEvent(win.document, 'focusin', () => {
|
|
this.captureYankBuffer(win);
|
|
});
|
|
}
|
|
async updateSelectionEvent() {
|
|
const view = this.getActiveView();
|
|
if (!view)
|
|
return;
|
|
let cm = this.getCodeMirror(view);
|
|
if (this.getCursorActivityHandlers(cm).some((e) => e.name === "updateSelection"))
|
|
return;
|
|
cm.on("cursorActivity", async (cm) => this.updateSelection(cm));
|
|
}
|
|
async updateSelection(cm) {
|
|
this.currentSelection = cm.listSelections();
|
|
}
|
|
getCursorActivityHandlers(cm) {
|
|
return cm._handlers.cursorActivity;
|
|
}
|
|
async updateVimEvents() {
|
|
if (!this.app.isVimEnabled())
|
|
return;
|
|
let view = this.getActiveView();
|
|
if (view) {
|
|
const cmEditor = this.getCodeMirror(view);
|
|
// See https://codemirror.net/doc/manual.html#vimapi_events for events.
|
|
this.isInsertMode = false;
|
|
this.currentVimStatus = "normal" /* vimStatus.normal */;
|
|
if (this.settings.displayVimMode)
|
|
this.updateVimStatusBar();
|
|
cmEditor.off('vim-mode-change', this.logVimModeChange);
|
|
cmEditor.on('vim-mode-change', this.logVimModeChange);
|
|
this.currentKeyChord = [];
|
|
cmEditor.off('vim-keypress', this.onVimKeypress);
|
|
cmEditor.on('vim-keypress', this.onVimKeypress);
|
|
cmEditor.off('vim-command-done', this.onVimCommandDone);
|
|
cmEditor.on('vim-command-done', this.onVimCommandDone);
|
|
CodeMirror.off(cmEditor.getInputField(), 'keydown', this.onKeydown);
|
|
CodeMirror.on(cmEditor.getInputField(), 'keydown', this.onKeydown);
|
|
}
|
|
}
|
|
async onload() {
|
|
await this.loadSettings();
|
|
this.addSettingTab(new SettingsTab(this.app, this));
|
|
console.log('loading Vimrc plugin');
|
|
this.app.workspace.on('active-leaf-change', async () => {
|
|
if (!this.initialized)
|
|
await this.initialize();
|
|
if (this.codeMirrorVimObject.loadedVimrc)
|
|
return;
|
|
let fileName = this.settings.vimrcFileName;
|
|
if (!fileName || fileName.trim().length === 0) {
|
|
fileName = DEFAULT_SETTINGS.vimrcFileName;
|
|
console.log('Configured Vimrc file name is illegal, falling-back to default');
|
|
}
|
|
let vimrcContent = '';
|
|
try {
|
|
vimrcContent = await this.app.vault.adapter.read(fileName);
|
|
}
|
|
catch (e) {
|
|
console.log('Error loading vimrc file', fileName, 'from the vault root', e.message);
|
|
}
|
|
this.readVimInit(vimrcContent);
|
|
});
|
|
}
|
|
async loadSettings() {
|
|
const data = await this.loadData();
|
|
this.settings = Object.assign({}, DEFAULT_SETTINGS, data);
|
|
}
|
|
async saveSettings() {
|
|
await this.saveData(this.settings);
|
|
}
|
|
onunload() {
|
|
console.log('unloading Vimrc plugin (but Vim commands that were already loaded will still work)');
|
|
}
|
|
getActiveView() {
|
|
return this.app.workspace.getActiveViewOfType(obsidian.MarkdownView);
|
|
}
|
|
getActiveObsidianEditor() {
|
|
return this.getActiveView().editor;
|
|
}
|
|
getCodeMirror(view) {
|
|
return view.editMode?.editor?.cm?.cm;
|
|
}
|
|
readVimInit(vimCommands) {
|
|
let view = this.getActiveView();
|
|
if (view) {
|
|
var cmEditor = this.getCodeMirror(view);
|
|
if (cmEditor && !this.codeMirrorVimObject.loadedVimrc) {
|
|
this.defineBasicCommands(this.codeMirrorVimObject);
|
|
this.defineAndMapObsidianVimCommands(this.codeMirrorVimObject);
|
|
this.defineSendKeys(this.codeMirrorVimObject);
|
|
this.defineObCommand(this.codeMirrorVimObject);
|
|
this.defineSurround(this.codeMirrorVimObject);
|
|
this.defineJsCommand(this.codeMirrorVimObject);
|
|
this.defineJsFile(this.codeMirrorVimObject);
|
|
this.defineSource(this.codeMirrorVimObject);
|
|
this.loadVimCommands(vimCommands);
|
|
// Make sure that we load it just once per CodeMirror instance.
|
|
// This is supposed to work because the Vim state is kept at the keymap level, hopefully
|
|
// there will not be bugs caused by operations that are kept at the object level instead
|
|
this.codeMirrorVimObject.loadedVimrc = true;
|
|
}
|
|
if (cmEditor) {
|
|
cmEditor.off('vim-mode-change', this.logVimModeChange);
|
|
cmEditor.on('vim-mode-change', this.logVimModeChange);
|
|
CodeMirror.off(cmEditor.getInputField(), 'keydown', this.onKeydown);
|
|
CodeMirror.on(cmEditor.getInputField(), 'keydown', this.onKeydown);
|
|
}
|
|
}
|
|
}
|
|
loadVimCommands(vimCommands) {
|
|
let view = this.getActiveView();
|
|
if (view) {
|
|
var cmEditor = this.getCodeMirror(view);
|
|
vimCommands.split("\n").forEach(function (line, index, arr) {
|
|
if (line.trim().length > 0 && line.trim()[0] != '"') {
|
|
let split = line.split(" ");
|
|
if (mappingCommands.includes(split[0])) {
|
|
// Have to do this because "vim-command-done" event doesn't actually work properly, or something.
|
|
this.customVimKeybinds[split[1]] = true;
|
|
}
|
|
this.codeMirrorVimObject.handleEx(cmEditor, line);
|
|
}
|
|
}.bind(this) // Faster than an arrow function. https://stackoverflow.com/questions/50375440/binding-vs-arrow-function-for-react-onclick-event
|
|
);
|
|
}
|
|
}
|
|
defineBasicCommands(vimObject) {
|
|
vimObject.defineOption('clipboard', '', 'string', ['clip'], (value, cm) => {
|
|
if (value) {
|
|
if (value.trim() == 'unnamed' || value.trim() == 'unnamedplus') {
|
|
if (!this.yankToSystemClipboard) {
|
|
this.yankToSystemClipboard = true;
|
|
console.log("Vim is now set to yank to system clipboard.");
|
|
}
|
|
}
|
|
else {
|
|
throw new Error("Unrecognized clipboard option, supported are 'unnamed' and 'unnamedplus' (and they do the same)");
|
|
}
|
|
}
|
|
});
|
|
vimObject.defineOption('tabstop', 4, 'number', [], (value, cm) => {
|
|
if (value && cm) {
|
|
cm.setOption('tabSize', value);
|
|
}
|
|
});
|
|
vimObject.defineEx('iunmap', '', (cm, params) => {
|
|
if (params.argString.trim()) {
|
|
this.codeMirrorVimObject.unmap(params.argString.trim(), 'insert');
|
|
}
|
|
});
|
|
vimObject.defineEx('nunmap', '', (cm, params) => {
|
|
if (params.argString.trim()) {
|
|
this.codeMirrorVimObject.unmap(params.argString.trim(), 'normal');
|
|
}
|
|
});
|
|
vimObject.defineEx('vunmap', '', (cm, params) => {
|
|
if (params.argString.trim()) {
|
|
this.codeMirrorVimObject.unmap(params.argString.trim(), 'visual');
|
|
}
|
|
});
|
|
vimObject.defineEx('noremap', '', (cm, params) => {
|
|
if (!params?.args?.length) {
|
|
throw new Error('Invalid mapping: noremap');
|
|
}
|
|
if (params.argString.trim()) {
|
|
this.codeMirrorVimObject.noremap.apply(this.codeMirrorVimObject, params.args);
|
|
}
|
|
});
|
|
// Allow the user to register an Ex command
|
|
vimObject.defineEx('exmap', '', (cm, params) => {
|
|
if (params?.args?.length && params.args.length < 2) {
|
|
throw new Error(`exmap requires at least 2 parameters: [name] [actions...]`);
|
|
}
|
|
let commandName = params.args[0];
|
|
params.args.shift();
|
|
let commandContent = params.args.join(' ');
|
|
// The content of the user's Ex command is just the remaining parameters of the exmap command
|
|
this.codeMirrorVimObject.defineEx(commandName, '', (cm, params) => {
|
|
this.codeMirrorVimObject.handleEx(cm, commandContent);
|
|
});
|
|
});
|
|
}
|
|
defineAndMapObsidianVimCommands(vimObject) {
|
|
defineAndMapObsidianVimMotion(vimObject, jumpToNextHeading, ']]');
|
|
defineAndMapObsidianVimMotion(vimObject, jumpToPreviousHeading, '[[');
|
|
defineAndMapObsidianVimMotion(vimObject, jumpToNextLink, 'gl');
|
|
defineAndMapObsidianVimMotion(vimObject, jumpToPreviousLink, 'gL');
|
|
defineAndMapObsidianVimAction(vimObject, this, moveDownSkippingFolds, 'zj');
|
|
defineAndMapObsidianVimAction(vimObject, this, moveUpSkippingFolds, 'zk');
|
|
defineAndMapObsidianVimAction(vimObject, this, followLinkUnderCursor, 'gf');
|
|
}
|
|
defineSendKeys(vimObject) {
|
|
vimObject.defineEx('sendkeys', '', async (cm, params) => {
|
|
if (!params?.args?.length) {
|
|
console.log(params);
|
|
throw new Error(`The sendkeys command requires a list of keys, e.g. sendKeys Ctrl+p a b Enter`);
|
|
}
|
|
let allGood = true;
|
|
let events = [];
|
|
for (const key of params.args) {
|
|
if (key.startsWith('wait')) {
|
|
const delay = key.slice(4);
|
|
await sleep(delay * 1000);
|
|
}
|
|
else {
|
|
let keyEvent = null;
|
|
try {
|
|
keyEvent = new KeyboardEvent('keydown', keyboardeventFromElectronAccelerator.toKeyEvent(key));
|
|
events.push(keyEvent);
|
|
}
|
|
catch (e) {
|
|
allGood = false;
|
|
throw new Error(`Key '${key}' couldn't be read as an Electron Accelerator`);
|
|
}
|
|
if (allGood) {
|
|
for (keyEvent of events)
|
|
window.postMessage(JSON.parse(JSON.stringify(keyEvent)), '*');
|
|
// view.containerEl.dispatchEvent(keyEvent);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
executeObsidianCommand(commandName) {
|
|
const availableCommands = this.app.commands.commands;
|
|
if (!(commandName in availableCommands)) {
|
|
throw new Error(`Command ${commandName} was not found, try 'obcommand' with no params to see in the developer console what's available`);
|
|
}
|
|
const view = this.getActiveView();
|
|
const editor = view.editor;
|
|
const command = availableCommands[commandName];
|
|
const { callback, checkCallback, editorCallback, editorCheckCallback } = command;
|
|
if (editorCheckCallback)
|
|
editorCheckCallback(false, editor, view);
|
|
else if (editorCallback)
|
|
editorCallback(editor, view);
|
|
else if (checkCallback)
|
|
checkCallback(false);
|
|
else if (callback)
|
|
callback();
|
|
else
|
|
throw new Error(`Command ${commandName} doesn't have an Obsidian callback`);
|
|
}
|
|
defineObCommand(vimObject) {
|
|
vimObject.defineEx('obcommand', '', async (cm, params) => {
|
|
if (!params?.args?.length || params.args.length != 1) {
|
|
const availableCommands = this.app.commands.commands;
|
|
console.log(`Available commands: ${Object.keys(availableCommands).join('\n')}`);
|
|
throw new Error(`obcommand requires exactly 1 parameter`);
|
|
}
|
|
const commandName = params.args[0];
|
|
this.executeObsidianCommand(commandName);
|
|
});
|
|
}
|
|
defineSurround(vimObject) {
|
|
// Function to surround selected text or highlighted word.
|
|
var surroundFunc = (params) => {
|
|
var editor = this.getActiveView().editor;
|
|
if (!params.length) {
|
|
throw new Error("surround requires exactly 2 parameters: prefix and postfix text.");
|
|
}
|
|
let newArgs = params.join(" ").match(/(\\.|[^\s\\\\]+)+/g);
|
|
if (newArgs.length != 2) {
|
|
throw new Error("surround requires exactly 2 parameters: prefix and postfix text.");
|
|
}
|
|
let beginning = newArgs[0].replace("\\\\", "\\").replace("\\ ", " "); // Get the beginning surround text
|
|
let ending = newArgs[1].replace("\\\\", "\\").replace("\\ ", " "); // Get the ending surround text
|
|
let currentSelections = this.currentSelection;
|
|
var chosenSelection = currentSelections?.[0] ? currentSelections[0] : { anchor: editor.getCursor(), head: editor.getCursor() };
|
|
if (currentSelections?.length > 1) {
|
|
console.log("WARNING: Multiple selections in surround. Attempt to select matching cursor. (obsidian-vimrc-support)");
|
|
const cursorPos = editor.getCursor();
|
|
for (const selection of currentSelections) {
|
|
if (selection.head.line == cursorPos.line && selection.head.ch == cursorPos.ch) {
|
|
console.log("RESOLVED: Selection matching cursor found. (obsidian-vimrc-support)");
|
|
chosenSelection = selection;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (editor.posToOffset(chosenSelection.anchor) === editor.posToOffset(chosenSelection.head)) {
|
|
// No range of selected text, so select word.
|
|
let wordAt = editor.wordAt(chosenSelection.head);
|
|
if (wordAt) {
|
|
chosenSelection = { anchor: wordAt.from, head: wordAt.to };
|
|
}
|
|
}
|
|
let currText;
|
|
if (editor.posToOffset(chosenSelection.anchor) > editor.posToOffset(chosenSelection.head)) {
|
|
currText = editor.getRange(chosenSelection.head, chosenSelection.anchor);
|
|
}
|
|
else {
|
|
currText = editor.getRange(chosenSelection.anchor, chosenSelection.head);
|
|
}
|
|
editor.replaceRange(beginning + currText + ending, chosenSelection.anchor, chosenSelection.head);
|
|
// If no selection, place cursor between beginning and ending
|
|
if (editor.posToOffset(chosenSelection.anchor) === editor.posToOffset(chosenSelection.head)) {
|
|
chosenSelection.head.ch += beginning.length;
|
|
editor.setCursor(chosenSelection.head);
|
|
}
|
|
};
|
|
vimObject.defineEx("surround", "", (cm, params) => { surroundFunc(params.args); });
|
|
vimObject.defineEx("pasteinto", "", (cm, params) => {
|
|
// Using the register for when this.yankToSystemClipboard == false
|
|
surroundFunc(['[',
|
|
'](' + vimObject.getRegisterController().getRegister('yank').keyBuffer + ")"]);
|
|
});
|
|
this.getActiveView().editor;
|
|
// Handle the surround dialog input
|
|
var surroundDialogCallback = (value) => {
|
|
if ((/^\[+$/).test(value)) { // check for 1-inf [ and match them with ]
|
|
surroundFunc([value, "]".repeat(value.length)]);
|
|
}
|
|
else if ((/^\(+$/).test(value)) { // check for 1-inf ( and match them with )
|
|
surroundFunc([value, ")".repeat(value.length)]);
|
|
}
|
|
else if ((/^\{+$/).test(value)) { // check for 1-inf { and match them with }
|
|
surroundFunc([value, "}".repeat(value.length)]);
|
|
}
|
|
else { // Else, just put it before and after.
|
|
surroundFunc([value, value]);
|
|
}
|
|
};
|
|
vimObject.defineOperator("surroundOperator", () => {
|
|
let p = "<span>Surround with: <input type='text'></span>";
|
|
CodeMirror.openDialog(p, surroundDialogCallback, { bottom: true, selectValueOnOpen: false });
|
|
});
|
|
vimObject.mapCommand("<A-y>s", "operator", "surroundOperator");
|
|
}
|
|
async captureYankBuffer(win) {
|
|
if (!this.yankToSystemClipboard) {
|
|
return;
|
|
}
|
|
const yankRegister = this.codeMirrorVimObject.getRegisterController().getRegister('yank');
|
|
const currentYankBuffer = yankRegister.keyBuffer;
|
|
// yank -> clipboard
|
|
const buf = currentYankBuffer[0];
|
|
if (buf !== this.lastYankBuffer[0]) {
|
|
await win.navigator.clipboard.writeText(buf);
|
|
this.lastYankBuffer = currentYankBuffer;
|
|
this.lastSystemClipboard = await win.navigator.clipboard.readText();
|
|
return;
|
|
}
|
|
// clipboard -> yank
|
|
try {
|
|
const currentClipboardText = await win.navigator.clipboard.readText();
|
|
if (currentClipboardText !== this.lastSystemClipboard) {
|
|
yankRegister.setText(currentClipboardText);
|
|
this.lastYankBuffer = yankRegister.keyBuffer;
|
|
this.lastSystemClipboard = currentClipboardText;
|
|
}
|
|
}
|
|
catch (e) {
|
|
// XXX: Avoid "Uncaught (in promise) DOMException: Document is not focused."
|
|
// XXX: It is not good but easy workaround
|
|
}
|
|
}
|
|
prepareChordDisplay() {
|
|
if (this.settings.displayChord) {
|
|
// Add status bar item
|
|
this.vimChordStatusBar = this.addStatusBarItem();
|
|
// Move vimChordStatusBar to the leftmost position and center it.
|
|
let parent = this.vimChordStatusBar.parentElement;
|
|
this.vimChordStatusBar.parentElement.insertBefore(this.vimChordStatusBar, parent.firstChild);
|
|
this.vimChordStatusBar.style.marginRight = "auto";
|
|
let cmEditor = this.getCodeMirror(this.getActiveView());
|
|
// See https://codemirror.net/doc/manual.html#vimapi_events for events.
|
|
cmEditor.off('vim-keypress', this.onVimKeypress);
|
|
cmEditor.on('vim-keypress', this.onVimKeypress);
|
|
cmEditor.off('vim-command-done', this.onVimCommandDone);
|
|
cmEditor.on('vim-command-done', this.onVimCommandDone);
|
|
}
|
|
}
|
|
prepareVimModeDisplay() {
|
|
if (this.settings.displayVimMode) {
|
|
this.vimStatusBar = this.addStatusBarItem(); // Add status bar item
|
|
this.vimStatusBar.setText(this.settings.vimStatusPromptMap["normal" /* vimStatus.normal */]); // Init the vimStatusBar with normal mode
|
|
this.vimStatusBar.addClass(vimStatusPromptClass);
|
|
this.vimStatusBar.dataset.vimMode = this.currentVimStatus;
|
|
}
|
|
}
|
|
defineJsCommand(vimObject) {
|
|
vimObject.defineEx('jscommand', '', (cm, params) => {
|
|
if (!this.settings.supportJsCommands)
|
|
throw new Error("JS commands are turned off; enable them via the Vimrc plugin configuration if you're sure you know what you're doing");
|
|
const jsCode = params.argString.trim();
|
|
if (jsCode[0] != '{' || jsCode[jsCode.length - 1] != '}')
|
|
throw new Error("Expected an argument which is JS code surrounded by curly brackets: {...}");
|
|
let currentSelections = this.currentSelection;
|
|
var chosenSelection = currentSelections && currentSelections.length > 0 ? currentSelections[0] : null;
|
|
const command = Function('editor', 'view', 'selection', jsCode);
|
|
const view = this.getActiveView();
|
|
command(view.editor, view, chosenSelection);
|
|
});
|
|
}
|
|
defineJsFile(vimObject) {
|
|
vimObject.defineEx('jsfile', '', async (cm, params) => {
|
|
if (!this.settings.supportJsCommands)
|
|
throw new Error("JS commands are turned off; enable them via the Vimrc plugin configuration if you're sure you know what you're doing");
|
|
if (params?.args?.length < 1)
|
|
throw new Error("Expected format: fileName {extraCode}");
|
|
let extraCode = '';
|
|
const fileName = params.args[0];
|
|
if (params.args.length > 1) {
|
|
params.args.shift();
|
|
extraCode = params.args.join(' ').trim();
|
|
if (extraCode[0] != '{' || extraCode[extraCode.length - 1] != '}')
|
|
throw new Error("Expected an extra code argument which is JS code surrounded by curly brackets: {...}");
|
|
}
|
|
let currentSelections = this.currentSelection;
|
|
var chosenSelection = currentSelections && currentSelections.length > 0 ? currentSelections[0] : null;
|
|
let content = '';
|
|
try {
|
|
content = await this.app.vault.adapter.read(fileName);
|
|
}
|
|
catch (e) {
|
|
throw new Error(`Cannot read file ${params.args[0]} from vault root: ${e.message}`);
|
|
}
|
|
const command = Function('editor', 'view', 'selection', content + extraCode);
|
|
const view = this.getActiveView();
|
|
command(view.editor, view, chosenSelection);
|
|
});
|
|
}
|
|
defineSource(vimObject) {
|
|
vimObject.defineEx('source', '', async (cm, params) => {
|
|
if (params?.args?.length > 1)
|
|
throw new Error("Expected format: source [fileName]");
|
|
const fileName = params.argString.trim();
|
|
try {
|
|
this.app.vault.adapter.read(fileName).then(vimrcContent => {
|
|
this.loadVimCommands(vimrcContent);
|
|
});
|
|
}
|
|
catch (e) {
|
|
console.log('Error loading vimrc file', fileName, 'from the vault root', e.message);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
class SettingsTab extends obsidian.PluginSettingTab {
|
|
constructor(app, plugin) {
|
|
super(app, plugin);
|
|
this.plugin = plugin;
|
|
}
|
|
display() {
|
|
let { containerEl } = this;
|
|
containerEl.empty();
|
|
containerEl.createEl('h2', { text: 'Vimrc Settings' });
|
|
new obsidian.Setting(containerEl)
|
|
.setName('Vimrc file name')
|
|
.setDesc('Relative to vault directory (requires restart)')
|
|
.addText((text) => {
|
|
text.setPlaceholder(DEFAULT_SETTINGS.vimrcFileName);
|
|
text.setValue(this.plugin.settings.vimrcFileName || DEFAULT_SETTINGS.vimrcFileName);
|
|
text.onChange(value => {
|
|
this.plugin.settings.vimrcFileName = value;
|
|
this.plugin.saveSettings();
|
|
});
|
|
});
|
|
new obsidian.Setting(containerEl)
|
|
.setName('Vim chord display')
|
|
.setDesc('Displays the current chord until completion. Ex: "<Space> f-" (requires restart)')
|
|
.addToggle((toggle) => {
|
|
toggle.setValue(this.plugin.settings.displayChord || DEFAULT_SETTINGS.displayChord);
|
|
toggle.onChange(value => {
|
|
this.plugin.settings.displayChord = value;
|
|
this.plugin.saveSettings();
|
|
});
|
|
});
|
|
new obsidian.Setting(containerEl)
|
|
.setName('Vim mode display')
|
|
.setDesc('Displays the current vim mode (requires restart)')
|
|
.addToggle((toggle) => {
|
|
toggle.setValue(this.plugin.settings.displayVimMode || DEFAULT_SETTINGS.displayVimMode);
|
|
toggle.onChange(value => {
|
|
this.plugin.settings.displayVimMode = value;
|
|
this.plugin.saveSettings();
|
|
});
|
|
});
|
|
new obsidian.Setting(containerEl)
|
|
.setName('Use a fixed keyboard layout for Normal mode')
|
|
.setDesc('Define a keyboard layout to always use when in Normal mode, regardless of the input language (experimental).')
|
|
.addButton(async (button) => {
|
|
button.setButtonText('Capture current layout');
|
|
button.onClick(async () => {
|
|
this.plugin.settings.capturedKeyboardMap = await this.plugin.captureKeyboardLayout();
|
|
this.plugin.saveSettings();
|
|
});
|
|
})
|
|
.addToggle((toggle) => {
|
|
toggle.setValue(this.plugin.settings.fixedNormalModeLayout || DEFAULT_SETTINGS.fixedNormalModeLayout);
|
|
toggle.onChange(async (value) => {
|
|
this.plugin.settings.fixedNormalModeLayout = value;
|
|
if (value && Object.keys(this.plugin.settings.capturedKeyboardMap).length === 0)
|
|
this.plugin.settings.capturedKeyboardMap = await this.plugin.captureKeyboardLayout();
|
|
this.plugin.saveSettings();
|
|
});
|
|
});
|
|
new obsidian.Setting(containerEl)
|
|
.setName('Support JS commands (beware!)')
|
|
.setDesc("Support the 'jscommand' and 'jsfile' commands, which allow defining Ex commands using Javascript. WARNING! Review the README to understand why this may be dangerous before enabling.")
|
|
.addToggle(toggle => {
|
|
toggle.setValue(this.plugin.settings.supportJsCommands ?? DEFAULT_SETTINGS.supportJsCommands);
|
|
toggle.onChange(value => {
|
|
this.plugin.settings.supportJsCommands = value;
|
|
this.plugin.saveSettings();
|
|
});
|
|
});
|
|
containerEl.createEl('h2', { text: 'Vim Mode Display Prompt' });
|
|
new obsidian.Setting(containerEl)
|
|
.setName('Normal mode prompt')
|
|
.setDesc('Set the status prompt text for normal mode.')
|
|
.addText((text) => {
|
|
text.setPlaceholder('Default: 🟢');
|
|
text.setValue(this.plugin.settings.vimStatusPromptMap.normal ||
|
|
DEFAULT_SETTINGS.vimStatusPromptMap.normal);
|
|
text.onChange((value) => {
|
|
this.plugin.settings.vimStatusPromptMap.normal = value ||
|
|
DEFAULT_SETTINGS.vimStatusPromptMap.normal;
|
|
this.plugin.saveSettings();
|
|
});
|
|
});
|
|
new obsidian.Setting(containerEl)
|
|
.setName('Insert mode prompt')
|
|
.setDesc('Set the status prompt text for insert mode.')
|
|
.addText((text) => {
|
|
text.setPlaceholder('Default: 🟠');
|
|
text.setValue(this.plugin.settings.vimStatusPromptMap.insert ||
|
|
DEFAULT_SETTINGS.vimStatusPromptMap.insert);
|
|
text.onChange((value) => {
|
|
this.plugin.settings.vimStatusPromptMap.insert = value ||
|
|
DEFAULT_SETTINGS.vimStatusPromptMap.insert;
|
|
console.log(this.plugin.settings.vimStatusPromptMap);
|
|
this.plugin.saveSettings();
|
|
});
|
|
});
|
|
new obsidian.Setting(containerEl)
|
|
.setName('Visual mode prompt')
|
|
.setDesc('Set the status prompt text for visual mode.')
|
|
.addText((text) => {
|
|
text.setPlaceholder('Default: 🟡');
|
|
text.setValue(this.plugin.settings.vimStatusPromptMap.visual ||
|
|
DEFAULT_SETTINGS.vimStatusPromptMap.visual);
|
|
text.onChange((value) => {
|
|
this.plugin.settings.vimStatusPromptMap.visual = value ||
|
|
DEFAULT_SETTINGS.vimStatusPromptMap.visual;
|
|
this.plugin.saveSettings();
|
|
});
|
|
});
|
|
new obsidian.Setting(containerEl)
|
|
.setName('Replace mode prompt')
|
|
.setDesc('Set the status prompt text for replace mode.')
|
|
.addText((text) => {
|
|
text.setPlaceholder('Default: 🔴');
|
|
text.setValue(this.plugin.settings.vimStatusPromptMap.replace ||
|
|
DEFAULT_SETTINGS.vimStatusPromptMap.replace);
|
|
text.onChange((value) => {
|
|
this.plugin.settings.vimStatusPromptMap.replace = value ||
|
|
DEFAULT_SETTINGS.vimStatusPromptMap.replace;
|
|
this.plugin.saveSettings();
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
module.exports = VimrcPlugin;
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/keyboardevent-from-electron-accelerator/index.js","actions/followLinkUnderCursor.ts","actions/moveSkippingFolds.ts","utils/jumpToPattern.ts","motions/jumpToHeading.ts","motions/jumpToLink.ts","utils/obsidianVimCommand.ts","main.ts"],"sourcesContent":["const modifiers = /^(CommandOrControl|CmdOrCtrl|Command|Cmd|Control|Ctrl|AltGr|Option|Alt|Shift|Super)/i;\nconst keyCodes = /^(Plus|Space|Tab|Backspace|Delete|Insert|Return|Enter|Up|Down|Left|Right|Home|End|PageUp|PageDown|Escape|Esc|VolumeUp|VolumeDown|VolumeMute|MediaNextTrack|MediaPreviousTrack|MediaStop|MediaPlayPause|PrintScreen|F24|F23|F22|F21|F20|F19|F18|F17|F16|F15|F14|F13|F12|F11|F10|F9|F8|F7|F6|F5|F4|F3|F2|F1|[0-9A-Z)!@#$%^&*(:+<_>?~{|}\";=,\\-./`[\\\\\\]'])/i;\nconst UNSUPPORTED = {};\n\nfunction _command(accelerator, event, modifier) {\n\tif (process.platform !== 'darwin') {\n\t\treturn UNSUPPORTED;\n\t}\n\n\tif (event.metaKey) {\n\t\tthrow new Error('Double `Command` modifier specified.');\n\t}\n\n\treturn {\n\t\tevent: Object.assign({}, event, {metaKey: true}),\n\t\taccelerator: accelerator.slice(modifier.length)\n\t};\n}\n\nfunction _super(accelerator, event, modifier) {\n\tif (event.metaKey) {\n\t\tthrow new Error('Double `Super` modifier specified.');\n\t}\n\n\treturn {\n\t\tevent: Object.assign({}, event, {metaKey: true}),\n\t\taccelerator: accelerator.slice(modifier.length)\n\t};\n}\n\nfunction _commandorcontrol(accelerator, event, modifier) {\n\tif (process.platform === 'darwin') {\n\t\tif (event.metaKey) {\n\t\t\tthrow new Error('Double `Command` modifier specified.');\n\t\t}\n\n\t\treturn {\n\t\t\tevent: Object.assign({}, event, {metaKey: true}),\n\t\t\taccelerator: accelerator.slice(modifier.length)\n\t\t};\n\t}\n\n\tif (event.ctrlKey) {\n\t\tthrow new Error('Double `Control` modifier specified.');\n\t}\n\n\treturn {\n\t\tevent: Object.assign({}, event, {ctrlKey: true}),\n\t\taccelerator: accelerator.slice(modifier.length)\n\t};\n}\n\nfunction _alt(accelerator, event, modifier) {\n\tif (modifier === 'option' && process.platform !== 'darwin') {\n\t\treturn UNSUPPORTED;\n\t}\n\n\tif (event.altKey) {\n\t\tthrow new Error('Double `Alt` modifier specified.');\n\t}\n\n\treturn {\n\t\tevent: Object.assign({}, event, {altKey: true}),\n\t\taccelerator: accelerator.slice(modifier.length)\n\t};\n}\n\nfunction _shift(accelerator, event, modifier) {\n\tif (event.shiftKey) {\n\t\tthrow new Error('Double `Shift` modifier specified.');\n\t}\n\n\treturn {\n\t\tevent: Object.assign({}, event, {shiftKey: true}),\n\t\taccelerator: accelerator.slice(modifier.length)\n\t};\n}\n\nfunction _control(accelerator, event, modifier) {\n\tif (event.ctrlKey) {\n\t\tthrow new Error('Double `Control` modifier specified.');\n\t}\n\n\treturn {\n\t\tevent: Object.assign({}, event, {ctrlKey: true}),\n\t\taccelerator: accelerator.slice(modifier.length)\n\t};\n}\n\nfunction reduceModifier({accelerator, event}, modifier) {\n\tswitch (modifier) {\n\t\tcase 'command':\n\t\tcase 'cmd': {\n\t\t\treturn _command(accelerator, event, modifier);\n\t\t}\n\n\t\tcase 'super': {\n\t\t\treturn _super(accelerator, event, modifier);\n\t\t}\n\n\t\tcase 'control':\n\t\tcase 'ctrl': {\n\t\t\treturn _control(accelerator, event, modifier);\n\t\t}\n\n\t\tcase 'commandorcontrol':\n\t\tcase 'cmdorctrl': {\n\t\t\treturn _commandorcontrol(accelerator, event, modifier);\n\t\t}\n\n\t\tcase 'option':\n\t\tcase 'altgr':\n\t\tcase 'alt': {\n\t\t\treturn _alt(accelerator, event, modifier);\n\t\t}\n\n\t\tcase 'shift': {\n\t\t\treturn _shift(accelerator, event, modifier);\n\t\t}\n\n\t\tdefault:\n\t\t\tconsole.error(modifier);\n\t}\n}\n\nfunction reducePlus({accelerator, event}) {\n\treturn {\n\t\tevent,\n\t\taccelerator: accelerator.trim().slice(1)\n\t};\n}\n\nconst virtualKeyCodes = {\n\t0: 'Digit0',\n\t1: 'Digit1',\n\t2: 'Digit2',\n\t3: 'Digit3',\n\t4: 'Digit4',\n\t5: 'Digit5',\n\t6: 'Digit6',\n\t7: 'Digit7',\n\t8: 'Digit8',\n\t9: 'Digit9',\n\t'-': 'Minus',\n\t'=': 'Equal',\n\tQ: 'KeyQ',\n\tW: 'KeyW',\n\tE: 'KeyE',\n\tR: 'KeyR',\n\tT: 'KeyT',\n\tY: 'KeyY',\n\tU: 'KeyU',\n\tI: 'KeyI',\n\tO: 'KeyO',\n\tP: 'KeyP',\n\t'[': 'BracketLeft',\n\t']': 'BracketRight',\n\tA: 'KeyA',\n\tS: 'KeyS',\n\tD: 'KeyD',\n\tF: 'KeyF',\n\tG: 'KeyG',\n\tH: 'KeyH',\n\tJ: 'KeyJ',\n\tK: 'KeyK',\n\tL: 'KeyL',\n\t';': 'Semicolon',\n\t'\\'': 'Quote',\n\t'`': 'Backquote',\n\t'/': 'Backslash',\n\tZ: 'KeyZ',\n\tX: 'KeyX',\n\tC: 'KeyC',\n\tV: 'KeyV',\n\tB: 'KeyB',\n\tN: 'KeyN',\n\tM: 'KeyM',\n\t',': 'Comma',\n\t'.': 'Period',\n\t'\\\\': 'Slash',\n\t' ': 'Space'\n};\n\nfunction reduceKey({accelerator, event}, key) {\n\tif (key.length > 1 || event.key) {\n\t\tthrow new Error(`Unvalid keycode \\`${key}\\`.`);\n\t}\n\n\tconst code =\n\t\tkey.toUpperCase() in virtualKeyCodes ?\n\t\t\tvirtualKeyCodes[key.toUpperCase()] :\n\t\t\tnull;\n\n\treturn {\n\t\tevent: Object.assign({}, event, {key}, code ? {code} : null),\n\t\taccelerator: accelerator.trim().slice(key.length)\n\t};\n}\n\nconst domKeys = Object.assign(Object.create(null), {\n\tplus: 'Add',\n\tspace: 'Space',\n\ttab: 'Tab',\n\tbackspace: 'Backspace',\n\tdelete: 'Delete',\n\tinsert: 'Insert',\n\treturn: 'Return',\n\tenter: 'Return',\n\tup: 'ArrowUp',\n\tdown: 'ArrowDown',\n\tleft: 'ArrowLeft',\n\tright: 'ArrowRight',\n\thome: 'Home',\n\tend: 'End',\n\tpageup: 'PageUp',\n\tpagedown: 'PageDown',\n\tescape: 'Escape',\n\tesc: 'Escape',\n\tvolumeup: 'AudioVolumeUp',\n\tvolumedown: 'AudioVolumeDown',\n\tvolumemute: 'AudioVolumeMute',\n\tmedianexttrack: 'MediaTrackNext',\n\tmediaprevioustrack: 'MediaTrackPrevious',\n\tmediastop: 'MediaStop',\n\tmediaplaypause: 'MediaPlayPause',\n\tprintscreen: 'PrintScreen'\n});\n\n// Add function keys\nfor (let i = 1; i <= 24; i++) {\n\tdomKeys[`f${i}`] = `F${i}`;\n}\n\nfunction reduceCode({accelerator, event}, {code, key}) {\n\tif (event.code) {\n\t\tthrow new Error(`Duplicated keycode \\`${key}\\`.`);\n\t}\n\n\treturn {\n\t\tevent: Object.assign({}, event, {key}, code ? {code} : null),\n\t\taccelerator: accelerator.trim().slice((key && key.length) || 0)\n\t};\n}\n\n/**\n * This function transform an Electron Accelerator string into\n * a DOM KeyboardEvent object.\n *\n * @param  {string} accelerator an Electron Accelerator string, e.g. `Ctrl+C` or `Shift+Space`.\n * @return {object} a DOM KeyboardEvent object derivate from the `accelerator` argument.\n */\nfunction toKeyEvent(accelerator) {\n\tlet state = {accelerator, event: {}};\n\twhile (state.accelerator !== '') {\n\t\tconst modifierMatch = state.accelerator.match(modifiers);\n\t\tif (modifierMatch) {\n\t\t\tconst modifier = modifierMatch[0].toLowerCase();\n\t\t\tstate = reduceModifier(state, modifier);\n\t\t\tif (state === UNSUPPORTED) {\n\t\t\t\treturn {unsupportedKeyForPlatform: true};\n\t\t\t}\n\t\t} else if (state.accelerator.trim()[0] === '+') {\n\t\t\tstate = reducePlus(state);\n\t\t} else {\n\t\t\tconst codeMatch = state.accelerator.match(keyCodes);\n\t\t\tif (codeMatch) {\n\t\t\t\tconst code = codeMatch[0].toLowerCase();\n\t\t\t\tif (code in domKeys) {\n\t\t\t\t\tstate = reduceCode(state, {\n\t\t\t\t\t\tcode: domKeys[code],\n\t\t\t\t\t\tkey: code\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tstate = reduceKey(state, code);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthrow new Error(`Unvalid accelerator: \"${state.accelerator}\"`);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn state.event;\n}\n\nmodule.exports = {\n\tUNSUPPORTED,\n\treduceModifier,\n\treducePlus,\n\treduceKey,\n\treduceCode,\n\ttoKeyEvent\n};\n","import { ObsidianActionFn } from \"../utils/obsidianVimCommand\";\n\n/**\n * Follows the link under the cursor, temporarily moving the cursor if necessary for follow-link to\n * work (i.e. if the cursor is on a starting square bracket).\n */\nexport const followLinkUnderCursor: ObsidianActionFn = (vimrcPlugin) => {\n  const obsidianEditor = vimrcPlugin.getActiveObsidianEditor();\n  const { line, ch } = obsidianEditor.getCursor();\n  const firstTwoChars = obsidianEditor.getRange(\n    { line, ch },\n    { line, ch: ch + 2 }\n  );\n  let numCharsMoved = 0;\n  for (const char of firstTwoChars) {\n    if (char === \"[\") {\n      obsidianEditor.exec(\"goRight\");\n      numCharsMoved++;\n    }\n  }\n  vimrcPlugin.executeObsidianCommand(\"editor:follow-link\");\n  // Move the cursor back to where it was\n  for (let i = 0; i < numCharsMoved; i++) {\n    obsidianEditor.exec(\"goLeft\");\n  }\n};\n","import VimrcPlugin from \"../main\";\nimport { ObsidianActionFn } from \"../utils/obsidianVimCommand\";\n\n/**\n * Moves the cursor down `repeat` lines, skipping over folded sections.\n */\nexport const moveDownSkippingFolds: ObsidianActionFn = (\n  vimrcPlugin,\n  cm,\n  { repeat }\n) => {\n  moveSkippingFolds(vimrcPlugin, repeat, \"down\");\n};\n\n/**\n * Moves the cursor up `repeat` lines, skipping over folded sections.\n */\nexport const moveUpSkippingFolds: ObsidianActionFn = (\n  vimrcPlugin,\n  cm,\n  { repeat }\n) => {\n  moveSkippingFolds(vimrcPlugin, repeat, \"up\");\n};\n\nfunction moveSkippingFolds(\n  vimrcPlugin: VimrcPlugin,\n  repeat: number,\n  direction: \"up\" | \"down\"\n) {\n  const obsidianEditor = vimrcPlugin.getActiveObsidianEditor();\n  let { line: oldLine, ch: oldCh } = obsidianEditor.getCursor();\n  const commandName = direction === \"up\" ? \"goUp\" : \"goDown\";\n  for (let i = 0; i < repeat; i++) {\n    obsidianEditor.exec(commandName);\n    const { line: newLine, ch: newCh } = obsidianEditor.getCursor();\n    if (newLine === oldLine && newCh === oldCh) {\n      // Going in the specified direction doesn't do anything anymore, stop now\n      return;\n    }\n    [oldLine, oldCh] = [newLine, newCh];\n  }\n}\n","import { Editor as CodeMirrorEditor } from \"codemirror\";\nimport { EditorPosition } from \"obsidian\";\n\n/**\n * Returns the position of the repeat-th instance of a pattern from a given cursor position, in the\n * given direction; looping to the other end of the document when reaching one end. Returns the\n * original cursor position if no match is found.\n *\n * Under the hood, to avoid repeated loops of the document: we get all matches at once, order them\n * according to `direction` and `cursorPosition`, and use modulo arithmetic to return the\n * appropriate match.\n *\n * @param cm The CodeMirror editor instance.\n * @param cursorPosition The current cursor position.\n * @param repeat The number of times to repeat the jump (e.g. 1 to jump to the very next match). Is\n * modulo-ed for efficiency.\n * @param regex The regex pattern to jump to.\n * @param filterMatch Optional filter function to run on the regex matches. Return false to ignore\n * a given match.\n * @param direction The direction to jump in.\n */\nexport function jumpToPattern({\n  cm,\n  cursorPosition,\n  repeat,\n  regex,\n  filterMatch = () => true,\n  direction,\n}: {\n  cm: CodeMirrorEditor;\n  cursorPosition: EditorPosition;\n  repeat: number;\n  regex: RegExp;\n  filterMatch?: (match: RegExpExecArray) => boolean;\n  direction: \"next\" | \"previous\";\n}): EditorPosition {\n  const content = cm.getValue();\n  const cursorIdx = cm.indexFromPos(cursorPosition);\n  const orderedMatches = getOrderedMatches({ content, regex, cursorIdx, filterMatch, direction });\n  const effectiveRepeat = (repeat % orderedMatches.length) || orderedMatches.length;\n  const matchIdx = orderedMatches[effectiveRepeat - 1]?.index;\n  if (matchIdx === undefined) {\n    return cursorPosition;\n  }\n  const newCursorPosition = cm.posFromIndex(matchIdx);\n  return newCursorPosition;\n}\n\n/**\n * Returns an ordered array of all matches of a regex in a string in the given direction from the\n * cursor index (looping around to the other end of the document when reaching one end).\n */\nfunction getOrderedMatches({\n  content,\n  regex,\n  cursorIdx,\n  filterMatch,\n  direction,\n}: {\n  content: string;\n  regex: RegExp;\n  cursorIdx: number;\n  filterMatch: (match: RegExpExecArray) => boolean;\n  direction: \"next\" | \"previous\";\n}): RegExpExecArray[] {\n  const { previousMatches, currentMatches, nextMatches } = getAndGroupMatches(\n    content,\n    regex,\n    cursorIdx,\n    filterMatch\n  );\n  if (direction === \"next\") {\n    return [...nextMatches, ...previousMatches, ...currentMatches];\n  }\n  return [\n    ...previousMatches.reverse(),\n    ...nextMatches.reverse(),\n    ...currentMatches.reverse(),\n  ];\n}\n\n/**\n * Finds all matches of a regex in a string and groups them by their positions relative to the\n * cursor.\n */\nfunction getAndGroupMatches(\n  content: string,\n  regex: RegExp,\n  cursorIdx: number,\n  filterMatch: (match: RegExpExecArray) => boolean\n): {\n  previousMatches: RegExpExecArray[];\n  currentMatches: RegExpExecArray[];\n  nextMatches: RegExpExecArray[];\n} {\n  const globalRegex = makeGlobalRegex(regex);\n  const allMatches = [...content.matchAll(globalRegex)].filter(filterMatch);\n  const previousMatches = allMatches.filter(\n    (match) => match.index < cursorIdx && !isWithinMatch(match, cursorIdx)\n  );\n  const currentMatches = allMatches.filter((match) => isWithinMatch(match, cursorIdx));\n  const nextMatches = allMatches.filter((match) => match.index > cursorIdx);\n  return { previousMatches, currentMatches, nextMatches };\n}\n\nfunction makeGlobalRegex(regex: RegExp): RegExp {\n  const globalFlags = getGlobalFlags(regex);\n  return new RegExp(regex.source, globalFlags);\n}\n\nfunction getGlobalFlags(regex: RegExp): string {\n  const { flags } = regex;\n  return flags.includes(\"g\") ? flags : `${flags}g`;\n}\n\nexport function isWithinMatch(match: RegExpExecArray, index: number): boolean {\n  return match.index <= index && index < match.index + match[0].length;\n}\n","import { Editor as CodeMirrorEditor } from \"codemirror\";\nimport { EditorPosition } from \"obsidian\";\nimport { isWithinMatch, jumpToPattern } from \"../utils/jumpToPattern\";\nimport { MotionFn } from \"../utils/vimApi\";\n\n/** Naive Regex for a Markdown heading (H1 through H6). \"Naive\" because it does not account for\n * whether the match is within a codeblock (e.g. it could be a Python comment, not a heading).\n */\nconst NAIVE_HEADING_REGEX = /^#{1,6} /gm;\n\n/** Regex for a Markdown fenced codeblock, which begins with some number >=3 of backticks at the\n * start of a line. It either ends on the nearest future line that starts with at least as many\n * backticks (\\1 back-reference), or extends to the end of the string if no such future line exists.\n */\nconst FENCED_CODEBLOCK_REGEX = /(^```+)(.*?^\\1|.*)/gms;\n\n/**\n * Jumps to the repeat-th next heading.\n */\nexport const jumpToNextHeading: MotionFn = (cm, cursorPosition, { repeat }) => {\n  return jumpToHeading({ cm, cursorPosition, repeat, direction: \"next\" });\n};\n\n/**\n * Jumps to the repeat-th previous heading.\n */\nexport const jumpToPreviousHeading: MotionFn = (\n  cm,\n  cursorPosition,\n  { repeat }\n) => {\n  return jumpToHeading({ cm, cursorPosition, repeat, direction: \"previous\" });\n};\n\n/**\n * Jumps to the repeat-th heading in the given direction.\n *\n * Under the hood, we use the naive heading regex to find all headings, and then filter out those\n * that are within codeblocks. `codeblockMatches` is passed in a closure to avoid repeated\n * computation.\n */\nfunction jumpToHeading({\n  cm,\n  cursorPosition,\n  repeat,\n  direction,\n}: {\n  cm: CodeMirrorEditor;\n  cursorPosition: EditorPosition;\n  repeat: number;\n  direction: \"next\" | \"previous\";\n}): EditorPosition {\n  const codeblockMatches = findAllCodeblocks(cm);\n  const filterMatch = (match: RegExpExecArray) => !isMatchWithinCodeblock(match, codeblockMatches);\n  return jumpToPattern({\n    cm,\n    cursorPosition,\n    repeat,\n    regex: NAIVE_HEADING_REGEX,\n    filterMatch,\n    direction,\n  });\n}\n\nfunction findAllCodeblocks(cm: CodeMirrorEditor): RegExpExecArray[] {\n  const content = cm.getValue();\n  return [...content.matchAll(FENCED_CODEBLOCK_REGEX)];\n}\n\nfunction isMatchWithinCodeblock(\n  match: RegExpExecArray,\n  codeblockMatches: RegExpExecArray[]\n): boolean {\n  return codeblockMatches.some((codeblockMatch) => isWithinMatch(codeblockMatch, match.index));\n}\n","import { jumpToPattern } from \"../utils/jumpToPattern\";\nimport { MotionFn } from \"../utils/vimApi\";\n\nconst WIKILINK_REGEX_STRING = \"\\\\[\\\\[.*?\\\\]\\\\]\";\nconst MARKDOWN_LINK_REGEX_STRING = \"\\\\[.*?\\\\]\\\\(.*?\\\\)\";\nconst URL_REGEX_STRING = \"\\\\w+://\\\\S+\";\n\n/**\n * Regex for a link (which can be a wikilink, a markdown link, or a standalone URL).\n */\nconst LINK_REGEX_STRING = `${WIKILINK_REGEX_STRING}|${MARKDOWN_LINK_REGEX_STRING}|${URL_REGEX_STRING}`;\nconst LINK_REGEX = new RegExp(LINK_REGEX_STRING, \"g\");\n\n/**\n * Jumps to the repeat-th next link.\n *\n * Note that `jumpToPattern` uses `String.matchAll`, which internally updates `lastIndex` after each\n * match; and that `LINK_REGEX` matches wikilinks / markdown links first. So, this won't catch\n * non-standalone URLs (e.g. the URL in a markdown link). This should be a good thing in most cases;\n * otherwise it could be tedious (as a user) for each markdown link to contain two jumpable spots.\n*/\nexport const jumpToNextLink: MotionFn = (cm, cursorPosition, { repeat }) => {\n  return jumpToPattern({\n    cm,\n    cursorPosition,\n    repeat,\n    regex: LINK_REGEX,\n    direction: \"next\",\n  });\n};\n\n/**\n * Jumps to the repeat-th previous link.\n */\nexport const jumpToPreviousLink: MotionFn = (cm, cursorPosition, { repeat }) => {\n  return jumpToPattern({\n    cm,\n    cursorPosition,\n    repeat,\n    regex: LINK_REGEX,\n    direction: \"previous\",\n  });\n};\n","/**\n * Utility types and functions for defining Obsidian-specific Vim commands.\n */\n\nimport { Editor as CodeMirrorEditor } from \"codemirror\";\n\nimport VimrcPlugin from \"../main\";\nimport { MotionFn, VimApi } from \"./vimApi\";\n\nexport type ObsidianActionFn = (\n  vimrcPlugin: VimrcPlugin,  // Included so we can run Obsidian commands as part of the action\n  cm: CodeMirrorEditor,\n  actionArgs: { repeat: number },\n) => void;\n\nexport function defineAndMapObsidianVimMotion(\n  vimObject: VimApi,\n  motionFn: MotionFn,\n  mapping: string\n) {\n  vimObject.defineMotion(motionFn.name, motionFn);\n  vimObject.mapCommand(mapping, \"motion\", motionFn.name, undefined, {});\n}\n\nexport function defineAndMapObsidianVimAction(\n  vimObject: VimApi,\n  vimrcPlugin: VimrcPlugin,\n  obsidianActionFn: ObsidianActionFn,\n  mapping: string\n) {\n  vimObject.defineAction(obsidianActionFn.name, (cm, actionArgs) => {\n    obsidianActionFn(vimrcPlugin, cm, actionArgs);\n  });\n  vimObject.mapCommand(mapping, \"action\", obsidianActionFn.name, undefined, {});\n}\n","import * as keyFromAccelerator from 'keyboardevent-from-electron-accelerator';\r\nimport { App, EditorSelection, MarkdownView, Notice, Editor as ObsidianEditor, Plugin, PluginSettingTab, Setting } from 'obsidian';\r\n\r\nimport { followLinkUnderCursor } from './actions/followLinkUnderCursor';\r\nimport { moveDownSkippingFolds, moveUpSkippingFolds } from './actions/moveSkippingFolds';\r\nimport { jumpToNextHeading, jumpToPreviousHeading } from './motions/jumpToHeading';\r\nimport { jumpToNextLink, jumpToPreviousLink } from './motions/jumpToLink';\r\nimport { defineAndMapObsidianVimAction, defineAndMapObsidianVimMotion } from './utils/obsidianVimCommand';\r\nimport { VimApi } from './utils/vimApi';\r\n\r\ndeclare const CodeMirror: any;\r\n\r\nconst enum vimStatus {\r\n\tnormal = 'normal',\r\n\tinsert = 'insert',\r\n\tvisual = 'visual',\r\n\treplace = 'replace',\r\n}\r\ntype VimStatusPrompt = string;\r\ntype VimStatusPromptMap = {\r\n\t[status in vimStatus]: VimStatusPrompt;\r\n};\r\n\r\ninterface Settings {\r\n\tvimrcFileName: string,\r\n\tdisplayChord: boolean,\r\n\tdisplayVimMode: boolean,\r\n\tfixedNormalModeLayout: boolean,\r\n\tcapturedKeyboardMap: Record<string, string>,\r\n\tsupportJsCommands?: boolean\r\n\tvimStatusPromptMap: VimStatusPromptMap;\r\n}\r\n\r\nconst DEFAULT_SETTINGS: Settings = {\r\n\tvimrcFileName: \".obsidian.vimrc\",\r\n\tdisplayChord: false,\r\n\tdisplayVimMode: false,\r\n\tfixedNormalModeLayout: false,\r\n\tcapturedKeyboardMap: {},\r\n\tsupportJsCommands: false,\r\n\tvimStatusPromptMap: {\r\n\t\tnormal: '🟢',\r\n\t\tinsert: '🟠',\r\n\t\tvisual: '🟡',\r\n\t\treplace: '🔴',\r\n\t},\r\n}\r\n\r\nconst vimStatusPromptClass = \"vimrc-support-vim-mode\";\r\n\r\n// NOTE: to future maintainers, please make sure all mapping commands are included in this array.\r\nconst mappingCommands: String[] = [\r\n\t\"map\",\r\n\t\"nmap\",\r\n\t\"noremap\",\r\n\t\"iunmap\",\r\n\t\"nunmap\",\r\n\t\"vunmap\",\r\n]\r\n\r\nfunction sleep(ms: number) {\r\n\treturn new Promise(resolve => setTimeout(resolve, ms));\r\n}\r\n\r\nexport default class VimrcPlugin extends Plugin {\r\n\tsettings: Settings;\r\n\r\n\tprivate codeMirrorVimObject: any = null;\r\n\tprivate initialized = false;\r\n\r\n\tprivate lastYankBuffer: string[] = [\"\"];\r\n\tprivate lastSystemClipboard = \"\";\r\n\tprivate yankToSystemClipboard: boolean = false;\r\n\tprivate currentKeyChord: any = [];\r\n\tprivate vimChordStatusBar: HTMLElement = null;\r\n\tprivate vimStatusBar: HTMLElement = null;\r\n\tprivate currentVimStatus: vimStatus = vimStatus.normal;\r\n\tprivate customVimKeybinds: { [name: string]: boolean } = {};\r\n\tprivate currentSelection: [EditorSelection] = null;\r\n\tprivate isInsertMode: boolean = false;\r\n\r\n\tupdateVimStatusBar() {\r\n\t\tthis.vimStatusBar.setText(\r\n\t\t\tthis.settings.vimStatusPromptMap[this.currentVimStatus]\r\n\t\t);\r\n\t\tthis.vimStatusBar.dataset.vimMode = this.currentVimStatus;\r\n\t}\r\n\r\n\tasync captureKeyboardLayout() {\r\n\t\t// This is experimental API and it might break at some point:\r\n\t\t// https://developer.mozilla.org/en-US/docs/Web/API/KeyboardLayoutMap\r\n\t\tlet keyMap: Record<string, string> = {};\r\n\t\tlet layout = await (navigator as any).keyboard.getLayoutMap();\r\n\t\tlet doneIterating = new Promise<void>((resolve, reject) => {\r\n\t\t\tlet counted = 0;\r\n\t\t\tlayout.forEach((value: any, index: any) => {\r\n\t\t\t\tkeyMap[index] = value;\r\n\t\t\t\tcounted += 1;\r\n\t\t\t\tif (counted === layout.size)\r\n\t\t\t\t\tresolve();\r\n\t\t\t});\r\n\t\t});\r\n\t\tawait doneIterating;\r\n\t\tnew Notice('Keyboard layout captured');\r\n\t\treturn keyMap;\r\n\t}\r\n\r\n\tasync initialize() {\r\n\t\tif (this.initialized)\r\n\t\t\treturn;\r\n\r\n\t\tthis.codeMirrorVimObject = (window as any).CodeMirrorAdapter?.Vim;\r\n\r\n\t\tthis.registerYankEvents(activeWindow);\r\n\t\tthis.app.workspace.on(\"window-open\", (workspaceWindow, w) => {\r\n\t\t\tthis.registerYankEvents(w);\r\n\t\t})\r\n\r\n\t\tthis.prepareChordDisplay();\r\n\t\tthis.prepareVimModeDisplay();\r\n\r\n\t\t// Two events cos\r\n\t\t// this don't trigger on loading/reloading obsidian with note opened\r\n\t\tthis.app.workspace.on(\"active-leaf-change\", async () => {\r\n\t\t\tthis.updateSelectionEvent();\r\n\r\n\t\t\tthis.updateVimEvents();\r\n\t\t});\r\n\t\t// and this don't trigger on opening same file in new pane\r\n\t\tthis.app.workspace.on(\"file-open\", async () => {\r\n\t\t\tthis.updateSelectionEvent();\r\n\r\n\t\t\tthis.updateVimEvents();\r\n\t\t});\r\n\r\n\t\tthis.initialized = true;\r\n\t}\r\n\r\n\tregisterYankEvents(win: Window) {\r\n\t\tthis.registerDomEvent(win.document, 'click', () => {\r\n\t\t\tthis.captureYankBuffer(win);\r\n\t\t});\r\n\t\tthis.registerDomEvent(win.document, 'keyup', () => {\r\n\t\t\tthis.captureYankBuffer(win);\r\n\t\t});\r\n\t\tthis.registerDomEvent(win.document, 'focusin', () => {\r\n\t\t\tthis.captureYankBuffer(win);\r\n\t\t})\r\n\t}\r\n\r\n\tasync updateSelectionEvent() {\r\n\t\tconst view = this.getActiveView();\r\n\t\tif (!view) return;\r\n\r\n\t\tlet cm = this.getCodeMirror(view);\r\n\t\tif (\r\n\t\t\tthis.getCursorActivityHandlers(cm).some(\r\n\t\t\t\t(e: { name: string }) => e.name === \"updateSelection\")\r\n\t\t) return;\r\n\t\tcm.on(\"cursorActivity\", async (cm: CodeMirror.Editor) => this.updateSelection(cm));\r\n\t}\r\n\r\n\tasync updateSelection(cm: any) {\r\n\t\tthis.currentSelection = cm.listSelections();\r\n\t}\r\n\r\n\tprivate getCursorActivityHandlers(cm: CodeMirror.Editor) {\r\n\t\treturn (cm as any)._handlers.cursorActivity;\r\n\t}\r\n\r\n\tasync updateVimEvents() {\r\n\t\tif (!(this.app as Any).isVimEnabled())\r\n\t\t\treturn;\r\n\t\tlet view = this.getActiveView();\r\n\t\tif (view) {\r\n\t\t\tconst cmEditor = this.getCodeMirror(view);\r\n\r\n\t\t\t// See https://codemirror.net/doc/manual.html#vimapi_events for events.\r\n\t\t\tthis.isInsertMode = false;\r\n\t\t\tthis.currentVimStatus = vimStatus.normal;\r\n\t\t\tif (this.settings.displayVimMode)\r\n\t\t\t\tthis.updateVimStatusBar();\r\n\t\t\tcmEditor.off('vim-mode-change', this.logVimModeChange);\r\n\t\t\tcmEditor.on('vim-mode-change', this.logVimModeChange);\r\n\r\n\t\t\tthis.currentKeyChord = [];\r\n\t\t\tcmEditor.off('vim-keypress', this.onVimKeypress);\r\n\t\t\tcmEditor.on('vim-keypress', this.onVimKeypress);\r\n\t\t\tcmEditor.off('vim-command-done', this.onVimCommandDone);\r\n\t\t\tcmEditor.on('vim-command-done', this.onVimCommandDone);\r\n\t\t\tCodeMirror.off(cmEditor.getInputField(), 'keydown', this.onKeydown);\r\n\t\t\tCodeMirror.on(cmEditor.getInputField(), 'keydown', this.onKeydown);\r\n\t\t}\r\n\t}\r\n\r\n\tasync onload() {\r\n\t\tawait this.loadSettings();\r\n\t\tthis.addSettingTab(new SettingsTab(this.app, this))\r\n\r\n\t\tconsole.log('loading Vimrc plugin');\r\n\r\n\t\tthis.app.workspace.on('active-leaf-change', async () => {\r\n\t\t\tif (!this.initialized)\r\n\t\t\t\tawait this.initialize();\r\n\t\t\tif (this.codeMirrorVimObject.loadedVimrc)\r\n\t\t\t\treturn;\r\n\t\t\tlet fileName = this.settings.vimrcFileName;\r\n\t\t\tif (!fileName || fileName.trim().length === 0) {\r\n\t\t\t\tfileName = DEFAULT_SETTINGS.vimrcFileName;\r\n\t\t\t\tconsole.log('Configured Vimrc file name is illegal, falling-back to default');\r\n\t\t\t}\r\n\t\t\tlet vimrcContent = '';\r\n\t\t\ttry {\r\n\t\t\t\tvimrcContent = await this.app.vault.adapter.read(fileName);\r\n\t\t\t} catch (e) {\r\n\t\t\t\tconsole.log('Error loading vimrc file', fileName, 'from the vault root', e.message)\r\n\t\t\t}\r\n\t\t\tthis.readVimInit(vimrcContent);\r\n\t\t});\r\n\t}\r\n\r\n\tasync loadSettings() {\r\n\t\tconst data = await this.loadData();\r\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, data);\r\n\t}\r\n\r\n\tasync saveSettings() {\r\n\t\tawait this.saveData(this.settings);\r\n\t}\r\n\r\n\tlogVimModeChange = async (cm: any) => {\r\n\t\tif (!cm) return;\r\n\t\tthis.isInsertMode = cm.mode === 'insert';\r\n\t\tswitch (cm.mode) {\r\n\t\t\tcase \"insert\":\r\n\t\t\t\tthis.currentVimStatus = vimStatus.insert;\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"normal\":\r\n\t\t\t\tthis.currentVimStatus = vimStatus.normal;\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"visual\":\r\n\t\t\t\tthis.currentVimStatus = vimStatus.visual;\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"replace\":\r\n\t\t\t\tthis.currentVimStatus = vimStatus.replace;\r\n\t\t\t\tbreak;\r\n\t\t\tdefault:\r\n\t\t\t\tbreak;\r\n\t\t}\r\n\t\tif (this.settings.displayVimMode)\r\n\t\t\tthis.updateVimStatusBar();\r\n\t}\r\n\r\n\tonunload() {\r\n\t\tconsole.log('unloading Vimrc plugin (but Vim commands that were already loaded will still work)');\r\n\t}\r\n\r\n\tprivate getActiveView(): MarkdownView {\r\n\t\treturn this.app.workspace.getActiveViewOfType(MarkdownView);\r\n\t}\r\n\r\n\tgetActiveObsidianEditor(): ObsidianEditor {\r\n\t\treturn this.getActiveView().editor;\r\n\t}\r\n\r\n\tprivate getCodeMirror(view: MarkdownView): CodeMirror.Editor {\r\n\t\treturn (view as any).editMode?.editor?.cm?.cm;\r\n\t}\r\n\r\n\treadVimInit(vimCommands: string) {\r\n\t\tlet view = this.getActiveView();\r\n\t\tif (view) {\r\n\t\t\tvar cmEditor = this.getCodeMirror(view);\r\n\t\t\tif (cmEditor && !this.codeMirrorVimObject.loadedVimrc) {\r\n\t\t\t\tthis.defineBasicCommands(this.codeMirrorVimObject);\r\n\t\t\t\tthis.defineAndMapObsidianVimCommands(this.codeMirrorVimObject);\r\n\t\t\t\tthis.defineSendKeys(this.codeMirrorVimObject);\r\n\t\t\t\tthis.defineObCommand(this.codeMirrorVimObject);\r\n\t\t\t\tthis.defineSurround(this.codeMirrorVimObject);\r\n\t\t\t\tthis.defineJsCommand(this.codeMirrorVimObject);\r\n\t\t\t\tthis.defineJsFile(this.codeMirrorVimObject);\r\n\t\t\t\tthis.defineSource(this.codeMirrorVimObject);\r\n\r\n\t\t\t\tthis.loadVimCommands(vimCommands);\r\n\r\n\t\t\t\t// Make sure that we load it just once per CodeMirror instance.\r\n\t\t\t\t// This is supposed to work because the Vim state is kept at the keymap level, hopefully\r\n\t\t\t\t// there will not be bugs caused by operations that are kept at the object level instead\r\n\t\t\t\tthis.codeMirrorVimObject.loadedVimrc = true;\r\n\t\t\t}\r\n\r\n\t\t\tif (cmEditor) {\r\n\t\t\t\tcmEditor.off('vim-mode-change', this.logVimModeChange);\r\n\t\t\t\tcmEditor.on('vim-mode-change', this.logVimModeChange);\r\n\t\t\t\tCodeMirror.off(cmEditor.getInputField(), 'keydown', this.onKeydown);\r\n\t\t\t\tCodeMirror.on(cmEditor.getInputField(), 'keydown', this.onKeydown);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tloadVimCommands(vimCommands: string) {\r\n\t\tlet view = this.getActiveView();\r\n\t\tif (view) {\r\n\t\t\tvar cmEditor = this.getCodeMirror(view);\r\n\r\n\t\t\tvimCommands.split(\"\\n\").forEach(\r\n\t\t\t\tfunction (line: string, index: number, arr: [string]) {\r\n\t\t\t\t\tif (line.trim().length > 0 && line.trim()[0] != '\"') {\r\n\t\t\t\t\t\tlet split = line.split(\" \")\r\n\t\t\t\t\t\tif (mappingCommands.includes(split[0])) {\r\n\t\t\t\t\t\t\t// Have to do this because \"vim-command-done\" event doesn't actually work properly, or something.\r\n\t\t\t\t\t\t\tthis.customVimKeybinds[split[1]] = true\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tthis.codeMirrorVimObject.handleEx(cmEditor, line);\r\n\t\t\t\t\t}\r\n\t\t\t\t}.bind(this) // Faster than an arrow function. https://stackoverflow.com/questions/50375440/binding-vs-arrow-function-for-react-onclick-event\r\n\t\t\t)\r\n\t\t}\r\n\t}\r\n\r\n\tdefineBasicCommands(vimObject: any) {\r\n\t\tvimObject.defineOption('clipboard', '', 'string', ['clip'], (value: string, cm: any) => {\r\n\t\t\tif (value) {\r\n\t\t\t\tif (value.trim() == 'unnamed' || value.trim() == 'unnamedplus') {\r\n\t\t\t\t\tif (!this.yankToSystemClipboard) {\r\n\t\t\t\t\t\tthis.yankToSystemClipboard = true;\r\n\t\t\t\t\t\tconsole.log(\"Vim is now set to yank to system clipboard.\");\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\tthrow new Error(\"Unrecognized clipboard option, supported are 'unnamed' and 'unnamedplus' (and they do the same)\")\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tvimObject.defineOption('tabstop', 4, 'number', [], (value: number, cm: any) => {\r\n\t\t\tif (value && cm) {\r\n\t\t\t\tcm.setOption('tabSize', value);\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tvimObject.defineEx('iunmap', '', (cm: any, params: any) => {\r\n\t\t\tif (params.argString.trim()) {\r\n\t\t\t\tthis.codeMirrorVimObject.unmap(params.argString.trim(), 'insert');\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tvimObject.defineEx('nunmap', '', (cm: any, params: any) => {\r\n\t\t\tif (params.argString.trim()) {\r\n\t\t\t\tthis.codeMirrorVimObject.unmap(params.argString.trim(), 'normal');\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tvimObject.defineEx('vunmap', '', (cm: any, params: any) => {\r\n\t\t\tif (params.argString.trim()) {\r\n\t\t\t\tthis.codeMirrorVimObject.unmap(params.argString.trim(), 'visual');\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tvimObject.defineEx('noremap', '', (cm: any, params: any) => {\r\n\t\t\tif (!params?.args?.length) {\r\n\t\t\t\tthrow new Error('Invalid mapping: noremap');\r\n\t\t\t}\r\n\r\n\t\t\tif (params.argString.trim()) {\r\n\t\t\t\tthis.codeMirrorVimObject.noremap.apply(this.codeMirrorVimObject, params.args);\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\t// Allow the user to register an Ex command\r\n\t\tvimObject.defineEx('exmap', '', (cm: any, params: any) => {\r\n\t\t\tif (params?.args?.length && params.args.length < 2) {\r\n\t\t\t\tthrow new Error(`exmap requires at least 2 parameters: [name] [actions...]`);\r\n\t\t\t}\r\n\t\t\tlet commandName = params.args[0];\r\n\t\t\tparams.args.shift();\r\n\t\t\tlet commandContent = params.args.join(' ');\r\n\t\t\t// The content of the user's Ex command is just the remaining parameters of the exmap command\r\n\t\t\tthis.codeMirrorVimObject.defineEx(commandName, '', (cm: any, params: any) => {\r\n\t\t\t\tthis.codeMirrorVimObject.handleEx(cm, commandContent);\r\n\t\t\t});\r\n\t\t});\r\n\t}\r\n\r\n  defineAndMapObsidianVimCommands(vimObject: VimApi) {\r\n\t\tdefineAndMapObsidianVimMotion(vimObject, jumpToNextHeading, ']]');\r\n\t\tdefineAndMapObsidianVimMotion(vimObject, jumpToPreviousHeading, '[[');\r\n\t\tdefineAndMapObsidianVimMotion(vimObject, jumpToNextLink, 'gl');\r\n\t\tdefineAndMapObsidianVimMotion(vimObject, jumpToPreviousLink, 'gL');\r\n\r\n\t\tdefineAndMapObsidianVimAction(vimObject, this, moveDownSkippingFolds, 'zj');\r\n\t\tdefineAndMapObsidianVimAction(vimObject, this, moveUpSkippingFolds, 'zk');\r\n\t\tdefineAndMapObsidianVimAction(vimObject, this, followLinkUnderCursor, 'gf');\r\n  }\r\n\r\n\tdefineSendKeys(vimObject: any) {\r\n\t\tvimObject.defineEx('sendkeys', '', async (cm: any, params: any) => {\r\n\t\t\tif (!params?.args?.length) {\r\n\t\t\t\tconsole.log(params);\r\n\t\t\t\tthrow new Error(`The sendkeys command requires a list of keys, e.g. sendKeys Ctrl+p a b Enter`);\r\n\t\t\t}\r\n\r\n\t\t\tlet allGood = true;\r\n\t\t\tlet events: KeyboardEvent[] = [];\r\n\t\t\tfor (const key of params.args) {\r\n\t\t\t\tif (key.startsWith('wait')) {\r\n\t\t\t\t\tconst delay = key.slice(4);\r\n\t\t\t\t\tawait sleep(delay * 1000);\r\n\t\t\t\t}\r\n\t\t\t\telse {\r\n\t\t\t\t\tlet keyEvent: KeyboardEvent = null;\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tkeyEvent = new KeyboardEvent('keydown', keyFromAccelerator.toKeyEvent(key));\r\n\t\t\t\t\t\tevents.push(keyEvent);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tcatch (e) {\r\n\t\t\t\t\t\tallGood = false;\r\n\t\t\t\t\t\tthrow new Error(`Key '${key}' couldn't be read as an Electron Accelerator`);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (allGood) {\r\n\t\t\t\t\t\tfor (keyEvent of events)\r\n\t\t\t\t\t\t\twindow.postMessage(JSON.parse(JSON.stringify(keyEvent)), '*');\r\n\t\t\t\t\t\t// view.containerEl.dispatchEvent(keyEvent);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\texecuteObsidianCommand(commandName: string) {\r\n\t\tconst availableCommands = (this.app as any).commands.commands;\r\n\t\tif (!(commandName in availableCommands)) {\r\n\t\t\tthrow new Error(`Command ${commandName} was not found, try 'obcommand' with no params to see in the developer console what's available`);\r\n\t\t}\r\n\t\tconst view = this.getActiveView();\r\n\t\tconst editor = view.editor;\r\n\t\tconst command = availableCommands[commandName];\r\n\t\tconst {callback, checkCallback, editorCallback, editorCheckCallback} = command;\r\n\t\tif (editorCheckCallback)\r\n\t\t\teditorCheckCallback(false, editor, view);\r\n\t\telse if (editorCallback)\r\n\t\t\teditorCallback(editor, view);\r\n\t\telse if (checkCallback)\r\n\t\t\tcheckCallback(false);\r\n\t\telse if (callback)\r\n\t\t\tcallback();\r\n\t\telse\r\n\t\t\tthrow new Error(`Command ${commandName} doesn't have an Obsidian callback`);\r\n\t}\r\n\r\n\tdefineObCommand(vimObject: any) {\r\n\t\tvimObject.defineEx('obcommand', '', async (cm: any, params: any) => {\r\n\t\t\tif (!params?.args?.length || params.args.length != 1) {\r\n\t\t\t\tconst availableCommands = (this.app as any).commands.commands;\r\n\t\t\t\tconsole.log(`Available commands: ${Object.keys(availableCommands).join('\\n')}`)\r\n\t\t\t\tthrow new Error(`obcommand requires exactly 1 parameter`);\r\n\t\t\t}\r\n\t\t\tconst commandName = params.args[0];\r\n\t\t\tthis.executeObsidianCommand(commandName);\r\n\t\t});\r\n\t}\r\n\r\n\tdefineSurround(vimObject: any) {\r\n\t\t// Function to surround selected text or highlighted word.\r\n\t\tvar surroundFunc = (params: string[]) => {\r\n\t\t\tvar editor = this.getActiveView().editor;\r\n\t\t\tif (!params.length) {\r\n\t\t\t\tthrow new Error(\"surround requires exactly 2 parameters: prefix and postfix text.\");\r\n\t\t\t}\r\n\t\t\tlet newArgs = params.join(\" \").match(/(\\\\.|[^\\s\\\\\\\\]+)+/g);\r\n\t\t\tif (newArgs.length != 2) {\r\n\t\t\t\tthrow new Error(\"surround requires exactly 2 parameters: prefix and postfix text.\");\r\n\t\t\t}\r\n\r\n\t\t\tlet beginning = newArgs[0].replace(\"\\\\\\\\\", \"\\\\\").replace(\"\\\\ \", \" \"); // Get the beginning surround text\r\n\t\t\tlet ending = newArgs[1].replace(\"\\\\\\\\\", \"\\\\\").replace(\"\\\\ \", \" \"); // Get the ending surround text\r\n\r\n            let currentSelections = this.currentSelection;\r\n\t\t\tvar chosenSelection = currentSelections?.[0] ? currentSelections[0] : {anchor: editor.getCursor(), head: editor.getCursor()};\r\n\t\t\tif (currentSelections?.length > 1) {\r\n\t\t\t\tconsole.log(\"WARNING: Multiple selections in surround. Attempt to select matching cursor. (obsidian-vimrc-support)\")\r\n\t\t\t\tconst cursorPos = editor.getCursor();\r\n\t\t\t\tfor (const selection of currentSelections) {\r\n\t\t\t\t\tif (selection.head.line == cursorPos.line && selection.head.ch == cursorPos.ch) {\r\n\t\t\t\t\t\tconsole.log(\"RESOLVED: Selection matching cursor found. (obsidian-vimrc-support)\")\r\n\t\t\t\t\t\tchosenSelection = selection;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (editor.posToOffset(chosenSelection.anchor) === editor.posToOffset(chosenSelection.head)) {\r\n\t\t\t\t// No range of selected text, so select word.\r\n\t\t\t\tlet wordAt = editor.wordAt(chosenSelection.head);\r\n\t\t\t\tif (wordAt) {\r\n\t\t\t\t\tchosenSelection = {anchor: wordAt.from, head: wordAt.to};\r\n\t\t\t\t}\r\n\t\t\t}\r\n            let currText;\r\n            if (editor.posToOffset(chosenSelection.anchor) > editor.posToOffset(chosenSelection.head)) {\r\n                currText = editor.getRange(chosenSelection.head, chosenSelection.anchor);\r\n            } else {\r\n                currText = editor.getRange(chosenSelection.anchor, chosenSelection.head);\r\n            }\r\n\t\t\teditor.replaceRange(beginning + currText + ending, chosenSelection.anchor, chosenSelection.head);\r\n\t\t\t// If no selection, place cursor between beginning and ending\r\n\t\t\tif (editor.posToOffset(chosenSelection.anchor) === editor.posToOffset(chosenSelection.head)) {\r\n\t\t\t\tchosenSelection.head.ch += beginning.length;\r\n\t\t\t\teditor.setCursor(chosenSelection.head);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tvimObject.defineEx(\"surround\", \"\", (cm: any, params: any) => { surroundFunc(params.args); });\r\n\r\n\t\tvimObject.defineEx(\"pasteinto\", \"\", (cm: any, params: any) => {\r\n\t\t\t// Using the register for when this.yankToSystemClipboard == false\r\n\t\t\tsurroundFunc(\r\n\t\t\t\t['[',\r\n\t\t\t\t '](' + vimObject.getRegisterController().getRegister('yank').keyBuffer + \")\"]);\r\n\t\t})\r\n\r\n\t\tvar editor = this.getActiveView().editor;\r\n\t\t// Handle the surround dialog input\r\n\t\tvar surroundDialogCallback = (value: string) => {\r\n\t\t\tif ((/^\\[+$/).test(value)) { // check for 1-inf [ and match them with ]\r\n\t\t\t\tsurroundFunc([value, \"]\".repeat(value.length)])\r\n\t\t\t} else if ((/^\\(+$/).test(value)) { // check for 1-inf ( and match them with )\r\n\t\t\t\tsurroundFunc([value, \")\".repeat(value.length)])\r\n\t\t\t} else if ((/^\\{+$/).test(value)) { // check for 1-inf { and match them with }\r\n\t\t\t\tsurroundFunc([value, \"}\".repeat(value.length)])\r\n\t\t\t} else { // Else, just put it before and after.\r\n\t\t\t\tsurroundFunc([value, value])\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tvimObject.defineOperator(\"surroundOperator\", () => {\r\n\t\t\tlet p = \"<span>Surround with: <input type='text'></span>\"\r\n\t\t\tCodeMirror.openDialog(p, surroundDialogCallback, { bottom: true, selectValueOnOpen: false })\r\n\t\t})\r\n\r\n\r\n\t\tvimObject.mapCommand(\"<A-y>s\", \"operator\", \"surroundOperator\")\r\n\r\n\t}\r\n\r\n\tasync captureYankBuffer(win: Window) {\r\n\t\tif (!this.yankToSystemClipboard) {\r\n\t\t\treturn\r\n\t\t}\r\n\r\n\t\tconst yankRegister = this.codeMirrorVimObject.getRegisterController().getRegister('yank');\r\n\t\tconst currentYankBuffer = yankRegister.keyBuffer;\r\n\r\n\t\t// yank -> clipboard\r\n\t\tconst buf = currentYankBuffer[0]\r\n\t\tif (buf !== this.lastYankBuffer[0]) {\r\n\t\t\tawait win.navigator.clipboard.writeText(buf);\r\n\t\t\tthis.lastYankBuffer = currentYankBuffer;\r\n\t\t\tthis.lastSystemClipboard = await win.navigator.clipboard.readText();\r\n\t\t\treturn\r\n\t\t}\r\n\r\n\t\t// clipboard -> yank\r\n\t\ttry {\r\n\t\t\tconst currentClipboardText = await win.navigator.clipboard.readText();\r\n\t\t\tif (currentClipboardText !== this.lastSystemClipboard) {\r\n\t\t\t\tyankRegister.setText(currentClipboardText);\r\n\t\t\t\tthis.lastYankBuffer = yankRegister.keyBuffer;\r\n\t\t\t\tthis.lastSystemClipboard = currentClipboardText;\r\n\t\t\t}\r\n\t\t} catch (e) {\r\n\t\t\t// XXX: Avoid \"Uncaught (in promise) DOMException: Document is not focused.\"\r\n\t\t\t// XXX: It is not good but easy workaround\r\n\t\t}\r\n\t}\r\n\r\n\tprepareChordDisplay() {\r\n\t\tif (this.settings.displayChord) {\r\n\t\t\t// Add status bar item\r\n\t\t\tthis.vimChordStatusBar = this.addStatusBarItem();\r\n\r\n\t\t\t// Move vimChordStatusBar to the leftmost position and center it.\r\n\t\t\tlet parent = this.vimChordStatusBar.parentElement;\r\n\t\t\tthis.vimChordStatusBar.parentElement.insertBefore(this.vimChordStatusBar, parent.firstChild);\r\n\t\t\tthis.vimChordStatusBar.style.marginRight = \"auto\";\r\n\r\n\t\t\tlet cmEditor = this.getCodeMirror(this.getActiveView());\r\n\t\t\t// See https://codemirror.net/doc/manual.html#vimapi_events for events.\r\n\t\t\tcmEditor.off('vim-keypress', this.onVimKeypress);\r\n\t\t\tcmEditor.on('vim-keypress', this.onVimKeypress);\r\n\t\t\tcmEditor.off('vim-command-done', this.onVimCommandDone);\r\n\t\t\tcmEditor.on('vim-command-done', this.onVimCommandDone);\r\n\t\t}\r\n\t}\r\n\r\n\tonVimKeypress = async (vimKey: any) => {\r\n\t\tif (vimKey != \"<Esc>\") { // TODO figure out what to actually look for to exit commands.\r\n\t\t\tthis.currentKeyChord.push(vimKey);\r\n\t\t\tif (this.customVimKeybinds[this.currentKeyChord.join(\"\")] != undefined) { // Custom key chord exists.\r\n\t\t\t\tthis.currentKeyChord = [];\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tthis.currentKeyChord = [];\r\n\t\t}\r\n\r\n\t\t// Build keychord text\r\n\t\tlet tempS = \"\";\r\n\t\tfor (const s of this.currentKeyChord) {\r\n\t\t\ttempS += \" \" + s;\r\n\t\t}\r\n\t\tif (tempS != \"\") {\r\n\t\t\ttempS += \"-\";\r\n\t\t}\r\n\t\tthis.vimChordStatusBar?.setText(tempS);\r\n\t}\r\n\r\n\tonVimCommandDone = async (reason: any) => {\r\n\t\tthis.vimChordStatusBar?.setText(\"\");\r\n\t\tthis.currentKeyChord = [];\r\n\t}\r\n\r\n\tprepareVimModeDisplay() {\r\n\t\tif (this.settings.displayVimMode) {\r\n\t\t\tthis.vimStatusBar = this.addStatusBarItem() // Add status bar item\r\n\t\t\tthis.vimStatusBar.setText(\r\n\t\t\t\tthis.settings.vimStatusPromptMap[vimStatus.normal]\r\n\t\t\t); // Init the vimStatusBar with normal mode\r\n\t\t\tthis.vimStatusBar.addClass(vimStatusPromptClass);\r\n\t\t\tthis.vimStatusBar.dataset.vimMode = this.currentVimStatus;\r\n\t\t}\r\n\t}\r\n\r\n\tonKeydown = (ev: KeyboardEvent) => {\r\n\t\tif (this.settings.fixedNormalModeLayout) {\r\n\t\t\tconst keyMap = this.settings.capturedKeyboardMap;\r\n\t\t\tif (!this.isInsertMode && !ev.shiftKey &&\r\n\t\t\t\tev.code in keyMap && ev.key != keyMap[ev.code]) {\r\n\t\t\t\tlet view = this.getActiveView();\r\n\t\t\t\tif (view) {\r\n\t\t\t\t\tconst cmEditor = this.getCodeMirror(view);\r\n\t\t\t\t\tif (cmEditor) {\r\n\t\t\t\t\t\tthis.codeMirrorVimObject.handleKey(cmEditor, keyMap[ev.code], 'mapping');\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\tev.preventDefault();\r\n\t\t\treturn false;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tdefineJsCommand(vimObject: any) {\r\n\t\tvimObject.defineEx('jscommand', '', (cm: any, params: any) => {\r\n\t\t\tif (!this.settings.supportJsCommands)\r\n\t\t\t\tthrow new Error(\"JS commands are turned off; enable them via the Vimrc plugin configuration if you're sure you know what you're doing\");\r\n\t\t\tconst jsCode = params.argString.trim() as string;\r\n\t\t\tif (jsCode[0] != '{' || jsCode[jsCode.length - 1] != '}')\r\n\t\t\t\tthrow new Error(\"Expected an argument which is JS code surrounded by curly brackets: {...}\");\r\n\t\t\tlet currentSelections = this.currentSelection;\r\n\t\t\tvar chosenSelection = currentSelections && currentSelections.length > 0 ? currentSelections[0] : null;\r\n\t\t\tconst command = Function('editor', 'view', 'selection', jsCode);\r\n\t\t\tconst view = this.getActiveView();\r\n\t\t\tcommand(view.editor, view, chosenSelection);\r\n\t\t});\r\n\t}\r\n\r\n\tdefineJsFile(vimObject: any) {\r\n\t\tvimObject.defineEx('jsfile', '', async (cm: any, params: any) => {\r\n\t\t\tif (!this.settings.supportJsCommands)\r\n\t\t\t\tthrow new Error(\"JS commands are turned off; enable them via the Vimrc plugin configuration if you're sure you know what you're doing\");\r\n\t\t\tif (params?.args?.length < 1)\r\n\t\t\t\tthrow new Error(\"Expected format: fileName {extraCode}\");\r\n\t\t\tlet extraCode = '';\r\n\t\t\tconst fileName = params.args[0];\r\n\t\t\tif (params.args.length > 1) {\r\n\t\t\t\tparams.args.shift();\r\n\t\t\t\textraCode = params.args.join(' ').trim() as string;\r\n\t\t\t\tif (extraCode[0] != '{' || extraCode[extraCode.length - 1] != '}')\r\n\t\t\t\t\tthrow new Error(\"Expected an extra code argument which is JS code surrounded by curly brackets: {...}\");\r\n\t\t\t}\r\n\t\t\tlet currentSelections = this.currentSelection;\r\n\t\t\tvar chosenSelection = currentSelections && currentSelections.length > 0 ? currentSelections[0] : null;\r\n\t\t\tlet content = '';\r\n\t\t\ttry {\r\n\t\t\t\tcontent = await this.app.vault.adapter.read(fileName);\r\n\t\t\t} catch (e) {\r\n\t\t\t\tthrow new Error(`Cannot read file ${params.args[0]} from vault root: ${e.message}`);\r\n\t\t\t}\r\n\t\t\tconst command = Function('editor', 'view', 'selection', content + extraCode);\r\n\t\t\tconst view = this.getActiveView();\r\n\t\t\tcommand(view.editor, view, chosenSelection);\r\n\t\t});\r\n\t}\r\n\r\n\tdefineSource(vimObject: any) {\r\n\t\tvimObject.defineEx('source', '', async (cm: any, params: any) => {\r\n\t\t\tif (params?.args?.length > 1)\r\n\t\t\t\tthrow new Error(\"Expected format: source [fileName]\");\r\n\t\t\tconst fileName = params.argString.trim();\r\n\t\t\ttry {\r\n\t\t\t\tthis.app.vault.adapter.read(fileName).then(vimrcContent => {\r\n\t\t\t\t\tthis.loadVimCommands(vimrcContent);\r\n\t\t\t\t});\r\n\t\t\t} catch (e) {\r\n\t\t\t\tconsole.log('Error loading vimrc file', fileName, 'from the vault root', e.message)\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n}\r\n\r\nclass SettingsTab extends PluginSettingTab {\r\n\tplugin: VimrcPlugin;\r\n\r\n\tconstructor(app: App, plugin: VimrcPlugin) {\r\n\t\tsuper(app, plugin);\r\n\t\tthis.plugin = plugin;\r\n\t}\r\n\r\n\tdisplay(): void {\r\n\t\tlet { containerEl } = this;\r\n\r\n\t\tcontainerEl.empty();\r\n\r\n\t\tcontainerEl.createEl('h2', { text: 'Vimrc Settings' });\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Vimrc file name')\r\n\t\t\t.setDesc('Relative to vault directory (requires restart)')\r\n\t\t\t.addText((text) => {\r\n\t\t\t\ttext.setPlaceholder(DEFAULT_SETTINGS.vimrcFileName);\r\n\t\t\t\ttext.setValue(this.plugin.settings.vimrcFileName || DEFAULT_SETTINGS.vimrcFileName);\r\n\t\t\t\ttext.onChange(value => {\r\n\t\t\t\t\tthis.plugin.settings.vimrcFileName = value;\r\n\t\t\t\t\tthis.plugin.saveSettings();\r\n\t\t\t\t})\r\n\t\t\t});\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Vim chord display')\r\n\t\t\t.setDesc('Displays the current chord until completion. Ex: \"<Space> f-\" (requires restart)')\r\n\t\t\t.addToggle((toggle) => {\r\n\t\t\t\ttoggle.setValue(this.plugin.settings.displayChord || DEFAULT_SETTINGS.displayChord);\r\n\t\t\t\ttoggle.onChange(value => {\r\n\t\t\t\t\tthis.plugin.settings.displayChord = value;\r\n\t\t\t\t\tthis.plugin.saveSettings();\r\n\t\t\t\t})\r\n\t\t\t});\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Vim mode display')\r\n\t\t\t.setDesc('Displays the current vim mode (requires restart)')\r\n\t\t\t.addToggle((toggle) => {\r\n\t\t\t\ttoggle.setValue(this.plugin.settings.displayVimMode || DEFAULT_SETTINGS.displayVimMode);\r\n\t\t\t\ttoggle.onChange(value => {\r\n\t\t\t\t\tthis.plugin.settings.displayVimMode = value;\r\n\t\t\t\t\tthis.plugin.saveSettings();\r\n\t\t\t\t})\r\n\t\t\t});\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Use a fixed keyboard layout for Normal mode')\r\n\t\t\t.setDesc('Define a keyboard layout to always use when in Normal mode, regardless of the input language (experimental).')\r\n\t\t\t.addButton(async (button) => {\r\n\t\t\t\tbutton.setButtonText('Capture current layout');\r\n\t\t\t\tbutton.onClick(async () => {\r\n\t\t\t\t\tthis.plugin.settings.capturedKeyboardMap = await this.plugin.captureKeyboardLayout();\r\n\t\t\t\t\tthis.plugin.saveSettings();\r\n\t\t\t\t});\r\n\t\t\t})\r\n\t\t\t.addToggle((toggle) => {\r\n\t\t\t\ttoggle.setValue(this.plugin.settings.fixedNormalModeLayout || DEFAULT_SETTINGS.fixedNormalModeLayout);\r\n\t\t\t\ttoggle.onChange(async value => {\r\n\t\t\t\t\tthis.plugin.settings.fixedNormalModeLayout = value;\r\n\t\t\t\t\tif (value && Object.keys(this.plugin.settings.capturedKeyboardMap).length === 0)\r\n\t\t\t\t\t\tthis.plugin.settings.capturedKeyboardMap = await this.plugin.captureKeyboardLayout();\r\n\t\t\t\t\tthis.plugin.saveSettings();\r\n\t\t\t\t});\r\n\t\t\t})\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Support JS commands (beware!)')\r\n\t\t\t.setDesc(\"Support the 'jscommand' and 'jsfile' commands, which allow defining Ex commands using Javascript. WARNING! Review the README to understand why this may be dangerous before enabling.\")\r\n\t\t\t.addToggle(toggle => {\r\n\t\t\t\ttoggle.setValue(this.plugin.settings.supportJsCommands ?? DEFAULT_SETTINGS.supportJsCommands);\r\n\t\t\t\ttoggle.onChange(value => {\r\n\t\t\t\t\tthis.plugin.settings.supportJsCommands = value;\r\n\t\t\t\t\tthis.plugin.saveSettings();\r\n\t\t\t\t})\r\n\t\t\t});\r\n\r\n\t\tcontainerEl.createEl('h2', {text: 'Vim Mode Display Prompt'});\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Normal mode prompt')\r\n\t\t\t.setDesc('Set the status prompt text for normal mode.')\r\n\t\t\t.addText((text) => {\r\n\t\t\t\ttext.setPlaceholder('Default: 🟢');\r\n\t\t\t\ttext.setValue(\r\n\t\t\t\t\tthis.plugin.settings.vimStatusPromptMap.normal ||\r\n\t\t\t\t\t\tDEFAULT_SETTINGS.vimStatusPromptMap.normal\r\n\t\t\t\t);\r\n\t\t\t\ttext.onChange((value) => {\r\n\t\t\t\t\tthis.plugin.settings.vimStatusPromptMap.normal = value ||\r\n\t\t\t\t\t\tDEFAULT_SETTINGS.vimStatusPromptMap.normal;\r\n\t\t\t\t\tthis.plugin.saveSettings();\r\n\t\t\t\t});\r\n\t\t\t});\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Insert mode prompt')\r\n\t\t\t.setDesc('Set the status prompt text for insert mode.')\r\n\t\t\t.addText((text) => {\r\n\t\t\t\ttext.setPlaceholder('Default: 🟠');\r\n\t\t\t\ttext.setValue(\r\n\t\t\t\t\tthis.plugin.settings.vimStatusPromptMap.insert ||\r\n\t\t\t\t\t\tDEFAULT_SETTINGS.vimStatusPromptMap.insert\r\n\t\t\t\t);\r\n\t\t\t\ttext.onChange((value) => {\r\n\t\t\t\t\tthis.plugin.settings.vimStatusPromptMap.insert = value ||\r\n\t\t\t\t\t\tDEFAULT_SETTINGS.vimStatusPromptMap.insert;\r\n\t\t\t\t\tconsole.log(this.plugin.settings.vimStatusPromptMap);\r\n\t\t\t\t\tthis.plugin.saveSettings();\r\n\t\t\t\t});\r\n\t\t\t});\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Visual mode prompt')\r\n\t\t\t.setDesc('Set the status prompt text for visual mode.')\r\n\t\t\t.addText((text) => {\r\n\t\t\t\ttext.setPlaceholder('Default: 🟡');\r\n\t\t\t\ttext.setValue(\r\n\t\t\t\t\tthis.plugin.settings.vimStatusPromptMap.visual ||\r\n\t\t\t\t\t\tDEFAULT_SETTINGS.vimStatusPromptMap.visual\r\n\t\t\t\t);\r\n\t\t\t\ttext.onChange((value) => {\r\n\t\t\t\t\tthis.plugin.settings.vimStatusPromptMap.visual = value ||\r\n\t\t\t\t\t\tDEFAULT_SETTINGS.vimStatusPromptMap.visual;\r\n\t\t\t\t\tthis.plugin.saveSettings();\r\n\t\t\t\t});\r\n\t\t\t});\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Replace mode prompt')\r\n\t\t\t.setDesc('Set the status prompt text for replace mode.')\r\n\t\t\t.addText((text) => {\r\n\t\t\t\ttext.setPlaceholder('Default: 🔴');\r\n\t\t\t\ttext.setValue(\r\n\t\t\t\t\tthis.plugin.settings.vimStatusPromptMap.replace ||\r\n\t\t\t\t\t\tDEFAULT_SETTINGS.vimStatusPromptMap.replace\r\n\t\t\t\t);\r\n\t\t\t\ttext.onChange((value) => {\r\n\t\t\t\t\tthis.plugin.settings.vimStatusPromptMap.replace = value ||\r\n\t\t\t\t\t\tDEFAULT_SETTINGS.vimStatusPromptMap.replace;\r\n\t\t\t\t\tthis.plugin.saveSettings();\r\n\t\t\t\t});\r\n\t\t\t});\r\n\t}\r\n}\r\n"],"names":["Plugin","Notice","MarkdownView","keyFromAccelerator.toKeyEvent","PluginSettingTab","Setting"],"mappings":"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"}
|