.config/coc/extensions/node_modules/coc-pairs/lib/index.js

   1 "use strict";
   2 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
   3     return new (P || (P = Promise))(function (resolve, reject) {
   4         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
   5         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
   6         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
   7         step((generator = generator.apply(thisArg, _arguments || [])).next());
   8     });
   9 };
  10 Object.defineProperty(exports, "__esModule", { value: true });
  11 const coc_nvim_1 = require("coc.nvim");
  12 const pairs = new Map();
  13 pairs.set('{', '}');
  14 pairs.set('[', ']');
  15 pairs.set('(', ')');
  16 pairs.set('<', '>');
  17 pairs.set('"', '"');
  18 pairs.set("'", "'");
  19 pairs.set('`', '`');
  20 function activate(context) {
  21     return __awaiter(this, void 0, void 0, function* () {
  22         let { subscriptions } = context;
  23         const config = coc_nvim_1.workspace.getConfiguration('pairs');
  24         const disableLanguages = config.get('disableLanguages');
  25         const characters = config.get('enableCharacters');
  26         const alwaysPairCharacters = config.get('alwaysPairCharacters', []);
  27         let enableBackspace = config.get('enableBackspace');
  28         if (enableBackspace) {
  29             let map = (yield coc_nvim_1.workspace.nvim.call('maparg', ['<bs>', 'i']));
  30             if (map && !map.startsWith('coc#_insert_key'))
  31                 enableBackspace = false;
  32         }
  33         if (characters.length == 0)
  34             return;
  35         const { nvim } = coc_nvim_1.workspace;
  36         function insertPair(character, pair) {
  37             return __awaiter(this, void 0, void 0, function* () {
  38                 let samePair = character == pair;
  39                 let arr = yield nvim.eval('[bufnr("%"),get(b:,"coc_pairs_disabled",[]),coc#util#cursor()]');
  40                 let doc = coc_nvim_1.workspace.getDocument(arr[0]);
  41                 if (!doc)
  42                     return character;
  43                 let { filetype } = doc;
  44                 if (disableLanguages.indexOf(filetype) !== -1)
  45                     return character;
  46                 let chars = arr[1];
  47                 if (chars && chars.length && chars.indexOf(character) !== -1)
  48                     return character;
  49                 let pos = { line: arr[2][0], character: arr[2][1] };
  50                 let line = doc.getline(pos.line);
  51                 let pre = line.slice(0, pos.character);
  52                 let rest = line.slice(pos.character);
  53                 let previous = pre.length ? pre[pre.length - 1] : '';
  54                 if (alwaysPairCharacters.indexOf(character) == -1 && rest && isWord(rest[0]))
  55                     return character;
  56                 if (character == '<' && (previous == ' ' || previous == '<')) {
  57                     return character;
  58                 }
  59                 if (samePair && rest[0] == character && rest[1] != character) {
  60                     // move position
  61                     yield nvim.eval(`feedkeys("\\<C-G>U\\<Right>", 'in')`);
  62                     return '';
  63                 }
  64                 if (samePair && pre && (isWord(previous) || previous == character))
  65                     return character;
  66                 // Only pair single quotes if previous character is not word.
  67                 if (character === "'" && pre.match(/.*\w$/)) {
  68                     return character;
  69                 }
  70                 // Rust: don't pair single quotes that are part of lifetime annotations Foo::<'a>
  71                 if (filetype === 'rust' && character === "'" && pre.endsWith('<')) {
  72                     return character;
  73                 }
  74                 if ((filetype === 'vim' || filetype === 'help') && character === '"' && pos.character === 0) {
  75                     return character;
  76                 }
  77                 if (samePair && pre.length >= 2 && previous == character && pre[pre.length - 2] == character) {
  78                     if (pre[pre.length - 3] == character) {
  79                         if (character == '"') {
  80                             nvim.command(`call feedkeys('"""'."${'\\<C-G>U\\<Left>'.repeat(3)}", 'in')`, true);
  81                         }
  82                         else {
  83                             nvim.command(`call feedkeys("${character.repeat(3)}${'\\<C-G>U\\<Left>'.repeat(3)}", 'in')`, true);
  84                         }
  85                         return;
  86                     }
  87                     return character;
  88                 }
  89                 if (character == '"') {
  90                     nvim.command(`call feedkeys('""'."\\<C-G>U\\<Left>", 'in')`, true);
  91                 }
  92                 else {
  93                     nvim.command(`call feedkeys("${character}${pair}${'\\<C-G>U\\<Left>'.repeat(pair.length)}", 'in')`, true);
  94                 }
  95                 return '';
  96             });
  97         }
  98         function closePair(character) {
  99             return __awaiter(this, void 0, void 0, function* () {
 100                 let bufnr = yield nvim.call('bufnr', '%');
 101                 let doc = coc_nvim_1.workspace.getDocument(bufnr);
 102                 if (!doc)
 103                     return character;
 104                 if (disableLanguages.indexOf(doc.filetype) !== -1)
 105                     return character;
 106                 let pos = yield coc_nvim_1.workspace.getCursorPosition();
 107                 let line = doc.getline(pos.line);
 108                 let rest = line.slice(pos.character);
 109                 if (rest[0] == character) {
 110                     nvim.command(`call feedkeys("\\<C-G>U\\<Right>", 'in')`, true);
 111                     return '';
 112                 }
 113                 return character;
 114             });
 115         }
 116         nvim.pauseNotification();
 117         for (let character of characters) {
 118             if (pairs.has(character)) {
 119                 subscriptions.push(coc_nvim_1.workspace.registerExprKeymap('i', character, insertPair.bind(null, character, pairs.get(character)), false));
 120             }
 121             let matched = pairs.get(character);
 122             if (matched != character) {
 123                 subscriptions.push(coc_nvim_1.workspace.registerExprKeymap('i', matched, closePair.bind(null, matched), false));
 124             }
 125         }
 126         if (enableBackspace) {
 127             subscriptions.push(coc_nvim_1.workspace.registerExprKeymap('i', '<bs>', onBackspace, false));
 128         }
 129         // tslint:disable-next-line: no-floating-promises
 130         nvim.resumeNotification(false, true);
 131         function createBufferKeymap(doc) {
 132             return __awaiter(this, void 0, void 0, function* () {
 133                 if (!doc)
 134                     return;
 135                 let pairs = doc.getVar('pairs', null);
 136                 if (!pairs)
 137                     return;
 138                 if (coc_nvim_1.workspace.bufnr != doc.bufnr)
 139                     return;
 140                 nvim.pauseNotification();
 141                 for (let p of pairs) {
 142                     if (Array.isArray(p) && p.length == 2) {
 143                         let [character, matched] = p;
 144                         subscriptions.push(coc_nvim_1.workspace.registerExprKeymap('i', character, insertPair.bind(null, character, matched), true));
 145                         if (matched != character) {
 146                             subscriptions.push(coc_nvim_1.workspace.registerExprKeymap('i', matched, closePair.bind(null, matched), true));
 147                         }
 148                     }
 149                 }
 150                 // tslint:disable-next-line: no-floating-promises
 151                 nvim.resumeNotification(false, true);
 152             });
 153         }
 154         yield createBufferKeymap(coc_nvim_1.workspace.getDocument(coc_nvim_1.workspace.bufnr));
 155         coc_nvim_1.workspace.onDidOpenTextDocument((e) => __awaiter(this, void 0, void 0, function* () {
 156             yield createBufferKeymap(coc_nvim_1.workspace.getDocument(e.uri));
 157         }));
 158     });
 159 }
 160 exports.activate = activate;
 161 // remove paired characters when possible
 162 function onBackspace() {
 163     return __awaiter(this, void 0, void 0, function* () {
 164         let { nvim } = coc_nvim_1.workspace;
 165         let res = yield nvim.eval('[getline("."),col("."),synIDattr(synID(line("."), col(".") - 2, 1), "name")]');
 166         if (res) {
 167             let [line, col, synname] = res;
 168             if (col > 1 && !/string/i.test(synname)) {
 169                 let buf = Buffer.from(line, 'utf8');
 170                 if (col - 1 < buf.length) {
 171                     let pre = buf.slice(col - 2, col - 1).toString('utf8');
 172                     let next = buf.slice(col - 1, col).toString('utf8');
 173                     if (pairs.has(pre) && pairs.get(pre) == next) {
 174                         yield nvim.eval(`feedkeys("\\<C-G>U\\<right>\\<bs>\\<bs>", 'in')`);
 175                         return;
 176                     }
 177                 }
 178             }
 179         }
 180         yield nvim.eval(`feedkeys("\\<bs>", 'in')`);
 181     });
 182 }
 183 function byteSlice(content, start, end) {
 184     let buf = Buffer.from(content, 'utf8');
 185     return buf.slice(start, end).toString('utf8');
 186 }
 187 exports.byteSlice = byteSlice;
 188 function wait(ms) {
 189     return new Promise(resolve => {
 190         setTimeout(() => {
 191             resolve();
 192         }, ms);
 193     });
 194 }
 195 exports.wait = wait;
 196 function isWord(character) {
 197     let code = character.charCodeAt(0);
 198     if (code > 128)
 199         return false;
 200     if (code == 95)
 201         return true;
 202     if (code >= 48 && code <= 57)
 203         return true;
 204     if (code >= 65 && code <= 90)
 205         return true;
 206     if (code >= 97 && code <= 122)
 207         return true;
 208     return false;
 209 }
 210 exports.isWord = isWord;
 211 //# sourceMappingURL=index.js.map