From 36c97b061684add2762e251ca8827b7e42cda382 Mon Sep 17 00:00:00 2001 From: douboer Date: Tue, 4 Nov 2025 20:59:23 +0800 Subject: [PATCH] update at 2025-11-04 20:59:23 --- deploy.sh | 120 ++++---- vim-im-switch-plugin/main.js | 465 +++++++++++++++++++++++++++++ vim-im-switch-plugin/manifest.json | 10 + vim-im-switch-plugin/styles.css | 2 + 4 files changed, 547 insertions(+), 50 deletions(-) create mode 100644 vim-im-switch-plugin/main.js create mode 100644 vim-im-switch-plugin/manifest.json create mode 100644 vim-im-switch-plugin/styles.css diff --git a/deploy.sh b/deploy.sh index 6734da0..e113f64 100755 --- a/deploy.sh +++ b/deploy.sh @@ -1,83 +1,103 @@ #!/bin/bash -# Obsidian Vim IM Switch Plugin 一键部署脚本 -# 编译并复制插件文件到 Obsidian 插件目录 +# Obsidian + Vim plugin one-click deploy script +set -e -set -e # 遇到错误时退出 - -# 颜色定义 RED='\033[0;31m' GREEN='\033[0;32m' YELLOW='\033[1;33m' BLUE='\033[0;34m' -NC='\033[0m' # No Color +NC='\033[0m' -# 配置 SOURCE_DIR="/Users/gavin/vim-im-switch" TARGET_DIR="/Users/gavin/myweb/.obsidian/plugins/vim-im-switch" -echo -e "${BLUE}🚀 开始部署 Obsidian Vim IM Switch Plugin...${NC}" +echo -e "${BLUE}🚀 Start deploy...${NC}" -# 检查源目录 if [ ! -d "$SOURCE_DIR" ]; then - echo -e "${RED}❌ 源目录不存在: $SOURCE_DIR${NC}" + echo -e "${RED}❌ Source dir not found: $SOURCE_DIR${NC}" exit 1 fi -# 进入源目录 cd "$SOURCE_DIR" -echo -e "${YELLOW}📁 当前目录: $(pwd)${NC}" +echo -e "${YELLOW}📁 Current: $(pwd)${NC}" -# 编译项目 -echo -e "${YELLOW}🔨 开始编译项目...${NC}" +echo -e "${YELLOW}🔨 Build project...${NC}" if npm run build; then - echo -e "${GREEN}✅ 编译成功${NC}" + echo -e "${GREEN}✅ Build success${NC}" else - echo -e "${RED}❌ 编译失败${NC}" + echo -e "${RED}❌ Build failed${NC}" exit 1 fi -# 检查编译产物（构建产物位于项目根，确保 main.js manifest.json styles.css 可用） -if [ ! -f "main.js" ] || [ ! -f "manifest.json" ] || [ ! -f "styles.css" ]; then - echo -e "${RED}❌ 编译产物缺失: 期待 main.js, manifest.json, styles.css 在项目根目录下${NC}" - ls -la | sed -n '1,200p' +if [ ! -f "main.js" ] && [ ! -f "vim-im-switch-plugin/main.js" ]; then + echo -e "${RED}❌ main.js not found in project or vim-im-switch-plugin/ (build output)${NC}" exit 1 fi -# 创建目标目录 -echo -e "${YELLOW}📂 创建目标目录...${NC}" +echo -e "${YELLOW}📂 Creating target dir...${NC}" mkdir -p "$TARGET_DIR" -# 复制文件 -echo -e "${YELLOW}📋 复制插件文件...${NC}" +echo -e "${YELLOW}📋 Copying plugin files...${NC}" -# 复制必需的文件到 Obsidian 插件目录 -cp -f main.js "$TARGET_DIR/" -cp -f manifest.json "$TARGET_DIR/" -cp -f styles.css "$TARGET_DIR/" - -echo -e "${GREEN}✅ Obsidian 插件文件复制完成:${NC}" -echo -e " • main.js" -echo -e " • manifest.json" -echo -e " • styles.css" - -# 复制 Vim 插件（fcitx-osx.vim） -echo -e "${YELLOW}📋 复制 Vim 插件...${NC}" -mkdir -p ~/.vim/plugin -if [ -f "fcitx-osx.vim" ]; then - cp -f fcitx-osx.vim ~/.vim/plugin/ - echo -e "${GREEN}✅ Vim 插件复制完成:${NC}" - echo -e " • fcitx-osx.vim → ~/.vim/plugin/" +# If build outputs are in vim-im-switch-plugin, prefer that directory +SRC_PLUGIN_DIR="$SOURCE_DIR" +if [ -d "$SOURCE_DIR/vim-im-switch-plugin" ]; then + SRC_PLUGIN_DIR="$SOURCE_DIR/vim-im-switch-plugin" else - echo -e "${YELLOW}⚠️ 未找到 fcitx-osx.vim，跳过 Vim 插件复制（确定文件存在于仓库根）${NC}" + # If build outputs are at project root, copy them into vim-im-switch-plugin for release + mkdir -p "$SOURCE_DIR/vim-im-switch-plugin" + for f in main.js manifest.json styles.css; do + if [ -f "$SOURCE_DIR/$f" ]; then + cp -f "$SOURCE_DIR/$f" "$SOURCE_DIR/vim-im-switch-plugin/" + echo -e "${GREEN}✔ Move $f -> $SOURCE_DIR/vim-im-switch-plugin/${NC}" + fi + done + SRC_PLUGIN_DIR="$SOURCE_DIR/vim-im-switch-plugin" fi -# 验证文件 -echo -e "${YELLOW}🔍 验证复制的文件...${NC}" -ls -la "$TARGET_DIR" +echo -e "${YELLOW}🔍 Using source dir: $SRC_PLUGIN_DIR${NC}" -echo -e "${GREEN}🎉 部署完成！${NC}" -echo -e "${BLUE}📍 Obsidian 插件已部署到: $TARGET_DIR${NC}" -echo -e "${BLUE}📍 Vim 插件已部署到: ~/.vim/plugin/${NC}" -echo -e "${YELLOW}💡 请重启 Obsidian 或重新加载插件以使更改生效${NC}" -echo -e "${YELLOW}💡 Vim 插件将在下次启动 Vim 时自动加载${NC}" +for f in main.js manifest.json styles.css; do + if [ -f "$SRC_PLUGIN_DIR/$f" ]; then + cp -f "$SRC_PLUGIN_DIR/$f" "$TARGET_DIR/" + echo -e "${GREEN}✔ Copied $f -> $TARGET_DIR/${NC}" + else + echo -e "${YELLOW}⚠️ Not found: $SRC_PLUGIN_DIR/$f (skipped)${NC}" + fi +done + +echo -e "${GREEN}✅ Obsidian plugin files copied (if available)${NC}" + +# Ensure repo-level release directory (vim-im-switch-plugin) contains the built files +RELEASE_DIR="$SOURCE_DIR/vim-im-switch-plugin" +mkdir -p "$RELEASE_DIR" +echo -e "${YELLOW}📦 Updating release dir: $RELEASE_DIR${NC}" +for f in main.js manifest.json styles.css; do + if [ -f "$SOURCE_DIR/$f" ]; then + cp -f "$SOURCE_DIR/$f" "$RELEASE_DIR/" + echo -e "${GREEN}✔ Copied $SOURCE_DIR/$f -> $RELEASE_DIR/${NC}" + else + if [ -f "$RELEASE_DIR/$f" ]; then + echo -e "${YELLOW}ℹ Using existing $RELEASE_DIR/$f${NC}" + else + echo -e "${RED}⚠️ Missing build output: $f (not found in project root or $RELEASE_DIR)${NC}" + fi + fi +done + +echo -e "${YELLOW}📋 Copying plugin files to Obsidian plugin dir: $TARGET_DIR${NC}" +for f in main.js manifest.json styles.css; do + if [ -f "$RELEASE_DIR/$f" ]; then + cp -f "$RELEASE_DIR/$f" "$TARGET_DIR/" + echo -e "${GREEN}✔ Copied $RELEASE_DIR/$f -> $TARGET_DIR/${NC}" + else + echo -e "${YELLOW}⚠️ Not found in release dir: $RELEASE_DIR/$f (skipped)${NC}" + fi +done + +echo -e "${GREEN}🎉 Deploy complete!${NC}" +echo -e " • Obsidian plugin -> $TARGET_DIR" +echo -e " • Release copy -> $RELEASE_DIR" + +echo -e "${YELLOW}💡 Restart Obsidian or reload plugin to take effect.${NC}" diff --git a/vim-im-switch-plugin/main.js b/vim-im-switch-plugin/main.js new file mode 100644 index 0000000..bb96b36 --- /dev/null +++ b/vim-im-switch-plugin/main.js @@ -0,0 +1,465 @@ +/* +THIS IS A GENERATED/BUNDLED FILE BY ROLLUP +if you want to view the source visit the plugins github repository +*/ + +'use strict'; + +var obsidian = require('obsidian'); +var child_process = require('child_process'); +var util = require('util'); + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}; + +const DEFAULT_SETTINGS = { + fcitxRemotePath_macOS: '/usr/local/bin/fcitx-remote', + fcitxRemotePath_windows: 'C:\\Program Files\\bin\\fcitx-remote', + fcitxRemotePath_linux: '/usr/bin/fcitx-remote', + englishInputMethod: 'com.apple.keylayout.ABC', + chineseInputMethod: 'auto-detect', // 将自动检测当前中文输入法 +}; +const pexec = util.promisify(child_process.exec); +var IMStatus; +(function (IMStatus) { + IMStatus[IMStatus["None"] = 0] = "None"; + IMStatus[IMStatus["Activate"] = 1] = "Activate"; + IMStatus[IMStatus["Deactivate"] = 2] = "Deactivate"; +})(IMStatus || (IMStatus = {})); +class VimIMSwitchPlugin extends obsidian.Plugin { + constructor() { + super(...arguments); + this.imStatus = IMStatus.None; + this.fcitxRemotePath = ""; + this.editorMode = null; + this.initialized = false; + this.cmEditor = null; + this.lastInsertModeIMStatus = IMStatus.None; // 记住上一次insert模式的输入法状态 + this.keyboardListenerSetup = false; // 防止重复设置键盘监听器 + this.lastKeyTime = 0; // 防抖：记录上次按键时间 + this.currentVimMode = 'normal'; // 跟踪当前vim模式 + this.onVimModeChange = (cm) => __awaiter(this, void 0, void 0, function* () { + // 防止短时间内重复处理相同的模式切换 + const currentTime = Date.now(); + if (cm.mode === this.currentVimMode && currentTime - this.lastKeyTime < 100) { + return; + } + // 更新当前vim模式状态 + this.currentVimMode = cm.mode; + if (cm.mode == "normal" || cm.mode == "visual") { + // 进入normal/visual模式前，先保存当前输入法状态 + yield this.getFcitxRemoteStatus(); + if (this.imStatus == IMStatus.Activate) { + this.lastInsertModeIMStatus = IMStatus.Activate; + } + console.log("🔤 [VimIMSwitch] → English"); + yield this.deactivateIM(); + } + else if (cm.mode == "insert" || cm.mode == "replace") { + // 进入insert模式时，恢复上次的输入法状态 + if (this.lastInsertModeIMStatus == IMStatus.Activate) { + console.log("🈳 [VimIMSwitch] → Chinese"); + yield this.activateIM(); + } + else { + console.log("🔤 [VimIMSwitch] → English"); + yield this.deactivateIM(); + } + } + }); + } + onload() { + return __awaiter(this, void 0, void 0, function* () { + console.log('🚀 [VimIMSwitch] Loading plugin...'); + yield this.loadSettings(); + // 尽早设置全局键盘监听器 + this.setupObsidianEditorEvents(); + this.addSettingTab(new IMSwitchSettingTab(this.app, this)); + this.addCommand({ + id: 'test-im-switch-to-english', + name: 'Test: Switch to English', + callback: () => { + this.deactivateIM(); + } + }); + this.addCommand({ + id: 'test-im-switch-to-chinese', + name: 'Test: Switch to Chinese', + callback: () => { + this.activateIM(); + } + }); + this.addCommand({ + id: 'test-check-im-status', + name: 'Test: Check IM Status', + callback: () => { + this.getFcitxRemoteStatus(); + } + }); + this.app.workspace.on('file-open', (file) => __awaiter(this, void 0, void 0, function* () { + if (!this.initialized) { + yield this.initialize(); + } + if (this.cmEditor) { + yield this.getFcitxRemoteStatus(); + this.lastInsertModeIMStatus = this.imStatus; + yield this.deactivateIM(); + if (typeof this.cmEditor.off === 'function') { + this.cmEditor.off("vim-mode-change", this.onVimModeChange); + } + if (typeof this.cmEditor.on === 'function') { + this.cmEditor.on("vim-mode-change", this.onVimModeChange); + } + } + })); + this.app.workspace.on('active-leaf-change', (leaf) => __awaiter(this, void 0, void 0, function* () { + if (this.app.workspace.activeLeaf.view.getViewType() == "markdown") { + if (!this.initialized) { + yield this.initialize(); + } + if (this.cmEditor) { + yield this.getFcitxRemoteStatus(); + this.lastInsertModeIMStatus = this.imStatus; + yield this.deactivateIM(); + this.setupObsidianEditorEvents(); + } + } + })); + }); + } + initialize() { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l; + return __awaiter(this, void 0, void 0, function* () { + if (this.initialized) { + return; + } + if ('editor:toggle-source' in this.app.commands.editorCommands) { + this.editorMode = 'cm6'; + } + else { + this.editorMode = 'cm5'; + } + const view = this.app.workspace.getActiveViewOfType(obsidian.MarkdownView); + if (view) { + if (this.editorMode == 'cm6') { + const possiblePaths = [ + (_c = (_b = (_a = view.sourceMode) === null || _a === void 0 ? void 0 : _a.cmEditor) === null || _b === void 0 ? void 0 : _b.cm) === null || _c === void 0 ? void 0 : _c.cm, + (_e = (_d = view.sourceMode) === null || _d === void 0 ? void 0 : _d.cmEditor) === null || _e === void 0 ? void 0 : _e.cm, + (_f = view.sourceMode) === null || _f === void 0 ? void 0 : _f.cmEditor, + (_g = view.editor) === null || _g === void 0 ? void 0 : _g.cm, + (_h = view.editor) === null || _h === void 0 ? void 0 : _h.cm + ]; + for (let i = 0; i < possiblePaths.length; i++) { + const path = possiblePaths[i]; + if (path && !this.cmEditor) { + this.cmEditor = path; + break; + } + } + } + else { + const possiblePaths = [ + (_j = view.sourceMode) === null || _j === void 0 ? void 0 : _j.cmEditor, + (_k = view.editor) === null || _k === void 0 ? void 0 : _k.cm, + (_l = view.editor) === null || _l === void 0 ? void 0 : _l.cm + ]; + for (let i = 0; i < possiblePaths.length; i++) { + const path = possiblePaths[i]; + if (path && !this.cmEditor) { + this.cmEditor = path; + break; + } + } + } + } + }); + } + setupVimModePolling() { + // 防止重复设置轮询 + if (this.vimModePollingInterval) { + clearInterval(this.vimModePollingInterval); + } + let lastMode = ""; + const pollInterval = setInterval(() => { + var _a, _b; + if (!this.cmEditor) { + return; + } + try { + const realCM = this.cmEditor.cm; + const currentMode = ((_b = (_a = realCM === null || realCM === void 0 ? void 0 : realCM.state) === null || _a === void 0 ? void 0 : _a.vim) === null || _b === void 0 ? void 0 : _b.mode) || ""; + if (currentMode && currentMode !== lastMode) { + this.onVimModeChange({ mode: currentMode }); + lastMode = currentMode; + } + } + catch (error) { + // 忽略轮询错误 + } + }, 100); + this.vimModePollingInterval = pollInterval; + } + setupObsidianEditorEvents() { + if (this.keyboardListenerSetup) { + return; + } + const handleKeyDown = (event) => __awaiter(this, void 0, void 0, function* () { + const currentTime = Date.now(); + // 防抖：100ms内只处理一次 + if (currentTime - this.lastKeyTime < 100) { + return; + } + this.lastKeyTime = currentTime; + // 处理ESC键：退出到normal模式 + if (event.key === 'Escape') { + // 退出insert模式前，先保存当前输入法状态 + const beforeIM = yield this.runCmd(this.fcitxRemotePath, ["-n"]); + const currentIMName = beforeIM.trim(); + // 检查当前输入法是中文还是英文 + if (currentIMName === this.settings.chineseInputMethod) { + this.lastInsertModeIMStatus = IMStatus.Activate; + console.log('🔤 [VimIMSwitch] ESC → English (saved Chinese)'); + } + else { + this.lastInsertModeIMStatus = IMStatus.Deactivate; + console.log('🔤 [VimIMSwitch] ESC → English (saved English)'); + } + // 切换到英文输入法 + this.currentVimMode = 'normal'; + yield this.deactivateIM(); + } + // 处理进入insert模式的按键（只在normal模式下） + else if (this.currentVimMode === 'normal' && + ['i', 'I', 'a', 'A', 'o', 'O', 's', 'S', 'c', 'C'].includes(event.key) && + !event.ctrlKey && !event.metaKey && !event.altKey) { + // 延迟一下，让Vim先切换模式 + setTimeout(() => __awaiter(this, void 0, void 0, function* () { + this.currentVimMode = 'insert'; + // 恢复上次的输入法状态 + if (this.lastInsertModeIMStatus == IMStatus.Activate) { + console.log("🈳 [VimIMSwitch] → Chinese"); + yield this.activateIM(); + } + else { + console.log("🔤 [VimIMSwitch] → English"); + yield this.deactivateIM(); + } + }), 10); + } + }); + // 移除旧的监听器 + if (this.obsidianKeyDownListener) { + document.removeEventListener('keydown', this.obsidianKeyDownListener, { capture: true }); + } + // 使用capture模式确保更早接收事件 + this.obsidianKeyDownListener = handleKeyDown; + document.addEventListener('keydown', handleKeyDown, { capture: true }); + this.keyboardListenerSetup = true; + } + runCmd(cmd, args = []) { + return __awaiter(this, void 0, void 0, function* () { + const output = yield pexec(`${cmd} ${args.join(" ")}`); + return output.stdout; + }); + } + getFcitxRemoteStatus() { + return __awaiter(this, void 0, void 0, function* () { + if (this.fcitxRemotePath == "") { + console.log("❌ [VimIMSwitch] Cannot get fcitx-remote path, please set it correctly."); + return; + } + try { + let fcitxRemoteOutput = yield this.runCmd(this.fcitxRemotePath); + fcitxRemoteOutput = fcitxRemoteOutput.trimRight(); + if (fcitxRemoteOutput == "1") { + this.imStatus = IMStatus.Deactivate; + } + else if (fcitxRemoteOutput == "2") { + this.imStatus = IMStatus.Activate; + } + else { + this.imStatus = IMStatus.None; + } + } + catch (error) { + console.log(`❌ [VimIMSwitch] Error getting IM status:`, error); + } + }); + } + activateIM() { + return __awaiter(this, void 0, void 0, function* () { + if (this.fcitxRemotePath == "") { + console.log("❌ [VimIMSwitch] Cannot get fcitx-remote path, please set it correctly."); + return; + } + try { + yield this.runCmd(this.fcitxRemotePath, ["-s", this.settings.chineseInputMethod]); + yield new Promise(resolve => setTimeout(resolve, 100)); + } + catch (error) { + console.log("❌ [VimIMSwitch] Error activating IM:", error); + } + }); + } + deactivateIM() { + return __awaiter(this, void 0, void 0, function* () { + if (this.fcitxRemotePath == "") { + console.log("❌ [VimIMSwitch] Cannot get fcitx-remote path, please set it correctly."); + return; + } + try { + yield this.runCmd(this.fcitxRemotePath, ["-s", this.settings.englishInputMethod]); + yield new Promise(resolve => setTimeout(resolve, 100)); + } + catch (error) { + console.log("❌ [VimIMSwitch] Error deactivating IM:", error); + } + }); + } + onunload() { + // 清理 CodeMirror 事件监听器 + if (this.cmEditor && typeof this.cmEditor.off === 'function') { + this.cmEditor.off("vim-mode-change", this.onVimModeChange); + } + // 清理轮询定时器 + if (this.vimModePollingInterval) { + clearInterval(this.vimModePollingInterval); + } + // 清理键盘事件监听器 + if (this.obsidianKeyDownListener) { + document.removeEventListener('keydown', this.obsidianKeyDownListener, { capture: true }); + this.keyboardListenerSetup = false; + } + } + loadSettings() { + return __awaiter(this, void 0, void 0, function* () { + this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData()); + yield this.updateCurrentPath(); + yield this.detectInputMethods(); + }); + } + detectInputMethods() { + return __awaiter(this, void 0, void 0, function* () { + if (this.settings.chineseInputMethod === 'auto-detect') { + try { + const currentIM = yield this.runCmd(this.fcitxRemotePath, ["-n"]); + const currentName = currentIM.trim(); + if (currentName.includes('pinyin') || + currentName.includes('chinese') || + currentName.includes('tencent') || + currentName.includes('sogou') || + currentName.includes('baidu')) { + this.settings.chineseInputMethod = currentName; + } + else { + this.settings.chineseInputMethod = 'com.tencent.inputmethod.wetype.pinyin'; + } + } + catch (error) { + this.settings.chineseInputMethod = 'com.tencent.inputmethod.wetype.pinyin'; + } + } + }); + } + updateCurrentPath() { + return __awaiter(this, void 0, void 0, function* () { + console.log(`🖥️ [VimIMSwitch] Platform detected: ${process.platform}`); + switch (process.platform) { + case 'darwin': + this.fcitxRemotePath = this.settings.fcitxRemotePath_macOS; + console.log(`🍎 [VimIMSwitch] Using macOS path: ${this.fcitxRemotePath}`); + break; + case 'linux': + this.fcitxRemotePath = this.settings.fcitxRemotePath_linux; + console.log(`🐧 [VimIMSwitch] Using Linux path: ${this.fcitxRemotePath}`); + break; + case 'win32': + this.fcitxRemotePath = this.settings.fcitxRemotePath_windows; + console.log(`🪟 [VimIMSwitch] Using Windows path: ${this.fcitxRemotePath}`); + break; + default: + console.log(`❌ [VimIMSwitch] Platform ${process.platform} is not supported currently.`); + break; + } + }); + } + saveSettings() { + return __awaiter(this, void 0, void 0, function* () { + yield this.saveData(this.settings); + }); + } +} +class IMSwitchSettingTab extends obsidian.PluginSettingTab { + constructor(app, plugin) { + super(app, plugin); + this.plugin = plugin; + } + display() { + let { containerEl } = this; + containerEl.empty(); + containerEl.createEl('h2', { text: 'Settings for Vim IM Switch plugin.' }); + new obsidian.Setting(containerEl) + .setName('Fcitx Remote Path for macOS') + .setDesc('The absolute path to fcitx-remote bin file on macOS.') + .addText(text => text + .setPlaceholder(DEFAULT_SETTINGS.fcitxRemotePath_macOS) + .setValue(this.plugin.settings.fcitxRemotePath_macOS) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.fcitxRemotePath_macOS = value; + this.plugin.updateCurrentPath(); + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Fcitx Remote Path for Linux') + .setDesc('The absolute path to fcitx-remote bin file on Linux.') + .addText(text => text + .setPlaceholder(DEFAULT_SETTINGS.fcitxRemotePath_linux) + .setValue(this.plugin.settings.fcitxRemotePath_linux) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.fcitxRemotePath_linux = value; + this.plugin.updateCurrentPath(); + yield this.plugin.saveSettings(); + }))); + new obsidian.Setting(containerEl) + .setName('Fcitx Remote Path for Windows') + .setDesc('The absolute path to fcitx-remote bin file on Windows.') + .addText(text => text + .setPlaceholder(DEFAULT_SETTINGS.fcitxRemotePath_windows) + .setValue(this.plugin.settings.fcitxRemotePath_windows) + .onChange((value) => __awaiter(this, void 0, void 0, function* () { + this.plugin.settings.fcitxRemotePath_windows = value; + this.plugin.updateCurrentPath(); + yield this.plugin.saveSettings(); + }))); + } +} + +module.exports = VimIMSwitchPlugin; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"main.js","sources":["node_modules/tslib/tslib.es6.js","main.ts"],"sourcesContent":null,"names":["promisify","exec","Plugin","MarkdownView","PluginSettingTab","Setting"],"mappings":"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"} diff --git a/vim-im-switch-plugin/manifest.json b/vim-im-switch-plugin/manifest.json new file mode 100644 index 0000000..af77345 --- /dev/null +++ b/vim-im-switch-plugin/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-vim-im-switch-plugin", + "name": "Vim Input Method Switch", + "version": "1.0.8", + "minAppVersion": "0.9.12", + "description": "Switch input method with fcitx-remote when Vim keymap is enabled.", + "author": "Yuan Chen", + "authorUrl": "https://github.com/yuanotes", + "isDesktopOnly": true +} diff --git a/vim-im-switch-plugin/styles.css b/vim-im-switch-plugin/styles.css new file mode 100644 index 0000000..47e1dc8 --- /dev/null +++ b/vim-im-switch-plugin/styles.css @@ -0,0 +1,2 @@ +body { +} \ No newline at end of file