init

1 files changed, 198 insertions, 0 deletions

diff --git a/SI/.obsidian/plugins/obsidian-scroll-offset/main.js b/SI/.obsidian/plugins/obsidian-scroll-offset/main.js
new file mode 100644
index 0000000..abd6d0f
--- /dev/null
+++ b/SI/.obsidian/plugins/obsidian-scroll-offset/main.js
@@ -0,0 +1,198 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/main.ts
+__export(exports, {
+  default: () => ScrollOffset
+});
+var import_obsidian = __toModule(require("obsidian"));
+
+// src/ScrollOffsetCM6.ts
+var import_view = __toModule(require("@codemirror/view"));
+var import_state = __toModule(require("@codemirror/state"));
+var eventHandlers = {
+  mousedown(event, view) {
+    this.switch = false;
+  },
+  keydown(event, view) {
+    this.switch = true;
+  }
+};
+function generateScrollOffsetCM6Plugin(calcRequiredOffset) {
+  return import_state.Prec.highest(import_view.ViewPlugin.fromClass(class {
+    constructor(_view) {
+      this.margin = 200;
+      this.switch = true;
+    }
+    update(_update) {
+      if (!_update.selectionSet)
+        return;
+      const view = _update.view;
+      view.requestMeasure({
+        read: () => {
+          return {
+            cursor: view.coordsAtPos(view.state.selection.main.head)
+          };
+        },
+        write: ({ cursor }) => {
+          if (!cursor)
+            return;
+          if (this.switch) {
+            const cursorHeight = cursor.bottom - cursor.top + 5;
+            const requiredOffset = calcRequiredOffset(view.dom, cursorHeight);
+            this.margin = requiredOffset;
+          } else {
+            this.margin = 0;
+          }
+        }
+      });
+    }
+  }, {
+    eventHandlers,
+    provide: (plugin) => import_view.EditorView.scrollMargins.of((view) => {
+      const value = view.plugin(plugin);
+      return {
+        top: value.margin,
+        bottom: value.margin
+      };
+    })
+  }));
+}
+var ScrollOffsetCM6_default = generateScrollOffsetCM6Plugin;
+
+// src/main.ts
+var DEFAULT_SETTINGS = {
+  percentageMode: true,
+  offset: "25"
+};
+var ScrollOffset = class extends import_obsidian.Plugin {
+  constructor() {
+    super(...arguments);
+    this.clickSwitch = true;
+    this.mouseDownHandler = () => {
+      this.clickSwitch = false;
+    };
+    this.cursorActiveHandler = (cm) => {
+      if (!this.clickSwitch) {
+        this.clickSwitch = true;
+        return;
+      }
+      this.scrollLaunch(cm);
+    };
+    this.calcRequiredOffset = (container, cursorHeight) => {
+      const { settings } = this;
+      const maxOffset = (container.offsetHeight - cursorHeight) / 2;
+      let requiredOffset = settings.percentageMode ? container.offsetHeight * +settings.offset / 100 : +settings.offset;
+      requiredOffset = Math.min(requiredOffset, maxOffset);
+      return requiredOffset;
+    };
+    this.scrollLaunch = (cm) => {
+      const cursor = cm.charCoords(cm.getCursor());
+      const cursorHeight = cursor.bottom - cursor.top + 5;
+      const container = cm.getWrapperElement();
+      const requiredOffset = this.calcRequiredOffset(container, cursorHeight);
+      cm.scrollIntoView(null, requiredOffset);
+    };
+    this.enableScrollOffset = () => {
+      this.registerCodeMirror((cm) => {
+        cm.on("mousedown", this.mouseDownHandler);
+        cm.on("cursorActivity", this.cursorActiveHandler);
+      });
+      this.registerEditorExtension(ScrollOffsetCM6_default(this.calcRequiredOffset));
+    };
+    this.disableScrollOffset = () => {
+      this.app.workspace.iterateCodeMirrors((cm) => {
+        cm.off("mousedown", this.mouseDownHandler);
+        cm.off("cursorActivity", this.cursorActiveHandler);
+      });
+    };
+  }
+  onload() {
+    return __async(this, null, function* () {
+      console.log("Loading Scroll Offset.");
+      yield this.loadSettings();
+      this.addSettingTab(new ScrollOffsetSettingTab(this.app, this));
+      this.enableScrollOffset();
+    });
+  }
+  onunload() {
+    this.disableScrollOffset();
+    console.log("Scroll Offset unloaded.");
+  }
+  loadSettings() {
+    return __async(this, null, function* () {
+      this.settings = Object.assign({}, DEFAULT_SETTINGS, yield this.loadData());
+    });
+  }
+  saveSettings() {
+    return __async(this, null, function* () {
+      yield this.saveData(this.settings);
+    });
+  }
+};
+var ScrollOffsetSettingTab = class extends import_obsidian.PluginSettingTab {
+  constructor(app, plugin) {
+    super(app, plugin);
+    this.plugin = plugin;
+  }
+  display() {
+    const { containerEl } = this;
+    containerEl.empty();
+    containerEl.createEl("h2", { text: "Scroll Offset Settings." });
+    new import_obsidian.Setting(containerEl).setName("Use percentage offset").setDesc("Use percentage offset, or use fixed number of distance instead").addToggle((comp) => comp.setValue(this.plugin.settings.percentageMode).onChange((value) => {
+      this.plugin.settings.percentageMode = value;
+      this.plugin.saveSettings();
+    }));
+    new import_obsidian.Setting(containerEl).setName("Distance").setDesc('unit in "px", or "%" if using percentage offset, 0 to disable this plugin').addText((text) => text.setValue(this.plugin.settings.offset).onChange((value) => {
+      this.plugin.settings.offset = value;
+      this.plugin.saveSettings();
+    }));
+  }
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/main.ts", "src/ScrollOffsetCM6.ts"],
  "sourcesContent": ["import { App, Plugin, PluginSettingTab, Setting } from 'obsidian';\r\nimport generateScrollOffsetCM6Plugin from './ScrollOffsetCM6';\r\n\r\ninterface ScrollOffsetSettings {\r\n\tpercentageMode: boolean;\r\n\toffset: string;\r\n}\r\n\r\nconst DEFAULT_SETTINGS: ScrollOffsetSettings = {\r\n\tpercentageMode: true,\r\n\toffset: '25',\r\n}\r\n\r\nexport default class ScrollOffset extends Plugin {\r\n\tprivate clickSwitch = true;\r\n\tsettings: ScrollOffsetSettings;\r\n\r\n\t// prevent click scroll\r\n\tmouseDownHandler = () => {\r\n\t\tthis.clickSwitch = false;\r\n\t}\r\n\r\n\t// CM5 scroll handler\r\n\tcursorActiveHandler = (cm: CodeMirror.Editor) => {\r\n\t\tif (!this.clickSwitch) {\r\n\t\t\tthis.clickSwitch = true;\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tthis.scrollLaunch(cm);\r\n\t}\r\n\r\n\tcalcRequiredOffset = (container: HTMLElement, cursorHeight: number) => {\r\n\t\tconst {settings} = this;\r\n\t\tconst maxOffset = (container.offsetHeight - cursorHeight) / 2;\r\n\r\n\t\tlet requiredOffset: number = settings.percentageMode\r\n\t\t\t? container.offsetHeight * +settings.offset / 100\r\n\t\t\t: +settings.offset;\r\n\t\r\n\t\trequiredOffset = Math.min(requiredOffset, maxOffset);\r\n\r\n\t\treturn requiredOffset\r\n\t}\r\n\r\n\tscrollLaunch = (cm: CodeMirror.Editor) => {\r\n\t\tconst cursor = cm.charCoords(cm.getCursor());\r\n\t\tconst cursorHeight = cursor.bottom - cursor.top + 5;\r\n\t\tconst container = cm.getWrapperElement();\r\n\t\tconst requiredOffset = this.calcRequiredOffset(container, cursorHeight);\r\n\r\n\t\t// First argument `null` means the cursor\r\n\t\tcm.scrollIntoView(null, requiredOffset)\r\n\t}\r\n\r\n\tenableScrollOffset = () => {\r\n\t\t// this works with CM5\r\n\t\tthis.registerCodeMirror(cm => {\r\n\t\t\tcm.on('mousedown', this.mouseDownHandler)\r\n\t\t\tcm.on('cursorActivity', this.cursorActiveHandler);\r\n\t\t})\r\n\r\n\t\t// this works with CM6\r\n\t\tthis.registerEditorExtension(generateScrollOffsetCM6Plugin(this.calcRequiredOffset));\r\n\t}\r\n\r\n\tdisableScrollOffset = () => {\r\n\t\tthis.app.workspace.iterateCodeMirrors(cm => {\r\n\t\t\tcm.off('mousedown', this.mouseDownHandler)\r\n\t\t\tcm.off('cursorActivity', this.cursorActiveHandler);\r\n\t\t})\r\n\t}\r\n\r\n\tasync onload() {\r\n\t\tconsole.log('Loading Scroll Offset.')\r\n\r\n\t\t// This load current settings.\r\n\t\tawait this.loadSettings();\r\n\r\n\t\t// This adds a settings tab so the user can configure various aspects of the plugin\r\n\t\tthis.addSettingTab(new ScrollOffsetSettingTab(this.app, this));\r\n\r\n\t\tthis.enableScrollOffset();\r\n\t}\r\n\r\n\tonunload() {\r\n\t\tthis.disableScrollOffset();\r\n\t\r\n\t\tconsole.log('Scroll Offset unloaded.')\r\n\t}\r\n\r\n\tasync loadSettings() {\r\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\r\n\t}\r\n\r\n\tasync saveSettings() {\r\n\t\tawait this.saveData(this.settings);\r\n\t}\r\n}\r\n\r\n// Settings tab\r\nclass ScrollOffsetSettingTab extends PluginSettingTab {\r\n\tplugin: ScrollOffset;\r\n\r\n\tconstructor(app: App, plugin: ScrollOffset) {\r\n\t\tsuper(app, plugin);\r\n\t\tthis.plugin = plugin;\r\n\t}\r\n\r\n\tdisplay(): void {\r\n\t\tconst {containerEl} = this;\r\n\r\n\t\tcontainerEl.empty();\r\n\r\n\t\tcontainerEl.createEl('h2', {text: 'Scroll Offset Settings.'});\r\n\r\n\t\tnew Setting(containerEl)\r\n\t\t\t.setName('Use percentage offset')\r\n\t\t\t.setDesc('Use percentage offset, or use fixed number of distance instead')\r\n\t\t\t.addToggle(comp => comp\r\n\t\t\t\t.setValue(this.plugin.settings.percentageMode)\r\n\t\t\t\t.onChange((value) => {\r\n\t\t\t\t\tthis.plugin.settings.percentageMode = 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('Distance')\r\n\t\t\t.setDesc('unit in \"px\", or \"%\" if using percentage offset, 0 to disable this plugin')\r\n\t\t\t.addText(text => text\r\n\t\t\t\t.setValue(this.plugin.settings.offset)\r\n\t\t\t\t.onChange((value) => {\r\n\t\t\t\t\tthis.plugin.settings.offset = value;\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", "import {ViewPlugin, ViewUpdate, EditorView} from '@codemirror/view';\nimport { Prec } from '@codemirror/state'\n\nconst eventHandlers = {\n  mousedown(event: MouseEvent, view: EditorView) {\n    this.switch = false;\n  },\n  keydown(event: KeyboardEvent, view: EditorView) {\n    this.switch = true;\n  },\n}\n\nfunction generateScrollOffsetCM6Plugin(calcRequiredOffset: (container: HTMLElement, cursorHeight: number) => number) {\n  return Prec.highest(ViewPlugin.fromClass(class {\n    margin = 200;\n    switch = true;\n  \n    constructor(_view: EditorView) {}\n  \n    update(_update: ViewUpdate) {\n      if (!_update.selectionSet) return ;\n\n      const view = _update.view;\n\n      view.requestMeasure({\n        read: () => {\n          return {\n            cursor: view.coordsAtPos(view.state.selection.main.head),\n          }\n        },\n        write: ({cursor}) => {\n          if (!cursor) return ;\n\n          if (this.switch) {\n            /**\n             * Can't use `lineHeight` because of multiple line paragraph\n             * But cursorHeight is less then lineHeight about 5px\n             * So add this 5px;\n             */\n            const cursorHeight = cursor.bottom - cursor.top + 5\n            const requiredOffset = calcRequiredOffset(view.dom, cursorHeight)\n\n            this.margin = requiredOffset;\n          } else {\n            this.margin = 0;\n          }\n        },\n      })\n    }\n  }, \n  {\n    eventHandlers,\n    provide: plugin => EditorView.scrollMargins.of(view => {\n      const value = view.plugin(plugin)\n      return {\n        top: value.margin,\n        bottom: value.margin\n      }\n    })\n  }))\n}\n\nexport default generateScrollOffsetCM6Plugin"],
  "mappings": "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",
  "names": []
}
