From 30f6b7c06039a2826d0d8bebf12e7ad88f1a6514 Mon Sep 17 00:00:00 2001 From: stargrey <90321926+stargrey@users.noreply.github.com> Date: Tue, 28 Jun 2022 15:05:38 +0800 Subject: [PATCH] update to 1.0.7 --- README.md | 4 +- main.js | 278 ++++++++++++++++++++++++++++++++--------------- main.ts | 290 +++++++++++++++++++++++++++++++++++++++----------- manifest.json | 2 +- styles.css | 29 +++++ 5 files changed, 457 insertions(+), 146 deletions(-) diff --git a/README.md b/README.md index 83cb17c..c8ae2b7 100644 --- a/README.md +++ b/README.md @@ -25,7 +25,9 @@ If you have a better idea, please submit an issue In version 1.0.4, add the language in the top right, like this: ![screenshots/image-20220601202203.png](screenshots/image-20220601202203.png) - +### Known issues +- Sometimes the auto linefeed error, can be solved by switching the preview mode once +- The PDF export cannot be auto linefeed ### Manually installing the plugin - Copy over `main.js`, `styles.css`, `manifest.json` to your vault `VaultFolder/.obsidian/plugins/obsidian-better-codeblock/`. diff --git a/main.js b/main.js index b8081a9..ce2fd20 100644 --- a/main.js +++ b/main.js @@ -56,6 +56,9 @@ var import_obsidian = __toModule(require("obsidian")); var DEFAULT_LANG = ""; var LANG_REG = /^language-/; var LINE_SPLIT_MARK = "\n"; +var titleRegExp = /TI:"([^"]*)"/i; +var highLightLinesRegExp = /HL:"([^"]*)"/i; +var foldRegExp = /"FOLD"/i; var CB_PADDING_TOP = "35px"; var DEFAULT_SETTINGS = { substitutionTokenForSpace: void 0, @@ -75,6 +78,9 @@ var BetterCodeBlock = class extends import_obsidian.Plugin { this.addSettingTab(new BetterCodeBlockTab(this.app, this)); this.registerMarkdownPostProcessor((el, ctx) => { BetterCodeBlocks(el, ctx, this); + app.workspace.on("resize", () => { + resizeNumWrapAndHLWrap(el, ctx); + }); }); }); } @@ -131,54 +137,76 @@ var BetterCodeBlockTab = class extends import_obsidian.PluginSettingTab { } }; function BetterCodeBlocks(el, context, plugin) { - const settings = plugin.settings; - const codeElm = el.querySelector("pre > code"); - if (!codeElm) { - return; - } - let lang = DEFAULT_LANG; - if (plugin.settings.excludeLangs.some((eLangName) => codeElm.classList.contains(`language-${eLangName}`))) { - return; - } - codeElm.classList.forEach((value, key, parent) => { - if (LANG_REG.test(value)) { - lang = value.replace("language-", ""); + return __async(this, null, function* () { + var _a; + const settings = plugin.settings; + const codeElm = el.querySelector("pre > code"); + if (!codeElm) { + return; + } + let lang = DEFAULT_LANG; + if (plugin.settings.excludeLangs.some((eLangName) => codeElm.classList.contains(`language-${eLangName}`))) { + return; + } + codeElm.classList.forEach((value, key, parent) => { + if (LANG_REG.test(value)) { + lang = value.replace("language-", ""); + return; + } + }); + if (lang == DEFAULT_LANG) { return; } + let codeBlock = context.getSectionInfo(codeElm); + let codeBlockFirstLine = ""; + if (codeBlock) { + let view = app.workspace.getActiveViewOfType(import_obsidian.MarkdownView); + codeBlockFirstLine = view.editor.getLine(codeBlock.lineStart); + } else { + let file = app.vault.getAbstractFileByPath(context.sourcePath); + let cache = app.metadataCache.getCache(context.sourcePath); + let fileContent = yield app.vault.cachedRead(file); + let fileContentLines = fileContent.split(/\n/g); + let codeBlockFirstLines = []; + let codeBlockSections = []; + (_a = cache.sections) == null ? void 0 : _a.forEach((element) => __async(this, null, function* () { + if (element.type == "code") { + let lineStart = element.position.start.line; + codeBlockFirstLine = fileContentLines[lineStart]; + codeBlockSections.push(element); + codeBlockFirstLines.push(codeBlockFirstLine); + } + })); + exportPDF(el, plugin, codeBlockFirstLines, codeBlockSections); + return; + } + let title = ""; + let highLightLines = []; + if (codeBlockFirstLine.match(titleRegExp) != null) { + title = codeBlockFirstLine.match(titleRegExp)[1]; + } + if (codeBlockFirstLine.match(highLightLinesRegExp) != null) { + let highLightLinesInfo = codeBlockFirstLine.match(highLightLinesRegExp)[1]; + highLightLines = analyseHighLightLines(highLightLinesInfo); + } + let isCollapse = false; + if (foldRegExp.test(codeBlockFirstLine)) { + isCollapse = true; + } + const pre = codeElm.parentElement; + const div = pre.parentElement; + const contentList = codeElm.textContent.split(LINE_SPLIT_MARK); + const lineSize = contentList.length - 1; + const cbMeta = { langName: lang, lineSize, pre, code: codeElm, title, isCollapse, div, contentList, highLightLines }; + const { showLineNumber } = plugin.settings; + addCodeTitleWrapper(plugin, pre, cbMeta); + addCodeTitle(plugin, pre, cbMeta); + if (showLineNumber) { + addLineNumber(plugin, cbMeta); + } + addLineHighLight(plugin, pre, cbMeta); + resizeNumWrapAndHLWrap(el, context); }); - if (lang == DEFAULT_LANG) { - return; - } - let titleRegExp = /TI:"([^"]*)"/i; - let highLightLinesRegExp = /HL:"([^"]*)"/i; - let foldRegExp = /"FOLD"/i; - let codeBlock = context.getSectionInfo(codeElm); - let view = app.workspace.getActiveViewOfType(import_obsidian.MarkdownView); - let codeBlockFirstLine = view.editor.getLine(codeBlock.lineStart); - let title = ""; - let highLightLines = []; - if (codeBlockFirstLine.match(titleRegExp) != null) { - title = codeBlockFirstLine.match(titleRegExp)[1]; - } - if (codeBlockFirstLine.match(highLightLinesRegExp) != null) { - let highLightLinesInfo = codeBlockFirstLine.match(highLightLinesRegExp)[1]; - highLightLines = analyseHighLightLines(highLightLinesInfo); - } - let isCollapse = false; - if (foldRegExp.test(codeBlockFirstLine)) { - isCollapse = true; - } - const pre = codeElm.parentElement; - const div = pre.parentElement; - const contentList = codeElm.textContent.split(LINE_SPLIT_MARK); - const lineSize = contentList.length - 1; - const cbMeta = { langName: lang, lineSize, pre, code: codeElm, title, isCollapse, div, contentList, highLightLines }; - const { showLineNumber } = plugin.settings; - addCodeTitle(plugin, pre, cbMeta); - if (showLineNumber) { - addLineNumber(plugin, cbMeta); - } - addLineHighLight(plugin, pre, cbMeta); } function createElement(tagName, defaultClassName) { const element = document.createElement(tagName); @@ -187,6 +215,47 @@ function createElement(tagName, defaultClassName) { } return element; } +function addCodeTitleWrapper(plugin, preElm, cbMeta) { + preElm.style.setProperty("position", "relative", "important"); + preElm.style.setProperty("padding-top", CB_PADDING_TOP, "important"); + let wrapper = document.createElement("pre"); + if (cbMeta.isCollapse) { + wrapper.setAttribute("closed", ""); + } + wrapper.className = "obsidian-embedded-code-title__code-block-title"; + wrapper.style.backgroundColor = plugin.settings.titleBackgroundColor || "#00000020"; + let collapser = createElement("div", "collapser"); + let handle = createElement("div", "handle"); + collapser.appendChild(handle); + wrapper.appendChild(collapser); + wrapper.addEventListener("click", function() { + if (wrapper.hasAttribute("closed")) { + wrapper.removeAttribute("closed"); + } else { + wrapper.setAttribute("closed", ""); + } + }); + preElm.appendChild(wrapper); +} +function addCodeTitle(plugin, preElm, cbMeta) { + let wrapper = preElm.querySelector(".obsidian-embedded-code-title__code-block-title"); + let titleElm = document.createElement("div"); + titleElm.className = "title"; + titleElm.appendText(cbMeta.title); + wrapper.appendChild(titleElm); + if (plugin.settings.titleFontColor) { + titleElm.style.setProperty("color", plugin.settings.titleFontColor, "important"); + } + if (plugin.settings.showLangNameInTopRight) { + let langName = document.createElement("div"); + let langNameString = cbMeta.langName; + langNameString = langNameString[0].toUpperCase() + langNameString.slice(1); + langName.appendText(langNameString); + langName.className = "langName"; + wrapper.appendChild(langName); + } + preElm.prepend(wrapper); +} function addLineNumber(plugin, cbMeta) { const { lineSize, pre, div } = cbMeta; div.classList.add("code-block-wrap"); @@ -202,42 +271,7 @@ function addLineNumber(plugin, cbMeta) { pre.appendChild(lineNumber); pre.classList.add("code-block-pre__has-linenum"); } -function addCodeTitle(plugin, wrapperElm, cbMeta) { - wrapperElm.style.setProperty("position", "relative", "important"); - wrapperElm.style.setProperty("padding-top", CB_PADDING_TOP, "important"); - wrapperElm.querySelectorAll(".obsidian-embedded-code-title__code-block-title").forEach((x) => x.remove()); - let d = document.createElement("pre"); - d.appendText(cbMeta.title); - if (cbMeta.isCollapse) { - d.setAttribute("closed", ""); - } - d.className = "obsidian-embedded-code-title__code-block-title"; - if (plugin.settings.titleFontColor) { - d.style.setProperty("color", plugin.settings.titleFontColor, "important"); - } - d.style.backgroundColor = plugin.settings.titleBackgroundColor || "#00000020"; - let collapser = createElement("div", "collapser"); - let handle = createElement("div", "handle"); - collapser.appendChild(handle); - d.appendChild(collapser); - if (plugin.settings.showLangNameInTopRight) { - let langName = document.createElement("div"); - let langNameString = cbMeta.langName; - langNameString = langNameString[0].toUpperCase() + langNameString.slice(1); - langName.appendText(langNameString); - langName.className = "langName"; - d.appendChild(langName); - } - d.addEventListener("click", function() { - if (d.hasAttribute("closed")) { - d.removeAttribute("closed"); - } else { - d.setAttribute("closed", ""); - } - }); - wrapperElm.prepend(d); -} -function addLineHighLight(plugin, wrapperElm, cbMeta) { +function addLineHighLight(plugin, preElm, cbMeta) { if (cbMeta.highLightLines.length == 0) return; let highLightWrap = document.createElement("pre"); @@ -249,7 +283,7 @@ function addLineHighLight(plugin, wrapperElm, cbMeta) { } highLightWrap.appendChild(singleLine); } - wrapperElm.appendChild(highLightWrap); + preElm.appendChild(highLightWrap); } function analyseHighLightLines(str) { str = str.replace(/\s*/g, ""); @@ -268,4 +302,82 @@ function analyseHighLightLines(str) { }); return result; } -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["main.ts"],
  "sourcesContent": ["import { linkSync } from 'fs';\nimport { App, Editor, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting, MarkdownPostProcessorContext, Menu, SettingTab, TAbstractFile, TFile } from 'obsidian';\n\nconst DEFAULT_LANG_ATTR = 'language-text'\nconst DEFAULT_LANG = ''\nconst LANG_REG = /^language-/\nconst LINE_SPLIT_MARK = '\\n'\n\nconst CB_PADDING_TOP = \"35px\" // \u4EE3\u7801\u5757\u4E0A\u8FB9\u8DDD\n\ninterface Settings {\n\tsubstitutionTokenForSpace: string;\n\ttitleBackgroundColor: string;\n\ttitleFontColor: string;\n\thighLightColor: string;\n\n\texcludeLangs: string[]; // \u9700\u8981\u6392\u9664\u7684\u8BED\u8A00\n\n\tshowLineNumber: boolean; // \u663E\u793A\u884C\u53F7\n\tshowDividingLine: boolean;\n\tshowLangNameInTopRight: boolean;\n}\n\nconst DEFAULT_SETTINGS: Settings = {\n\tsubstitutionTokenForSpace: undefined,\n\ttitleBackgroundColor: \"#00000020\",\n\ttitleFontColor: undefined,\n\thighLightColor: \"#2d82cc20\",\n\n\texcludeLangs: [],\n\n\tshowLineNumber: true,\n\tshowDividingLine: false,\n\tshowLangNameInTopRight: true\n};\n\ninterface CodeBlockMeta {\n\t// Language name\n\tlangName: string;\n\n\t// Code block total line size\n\tlineSize: number;\n\n\t// Code block 'pre' HTMLElement\n\tpre: HTMLElement;\n\n\t// Code block 'code' HTMLElement\n\tcode: HTMLElement;\n\n\ttitle: string; // \u4EE3\u7801\u5757\u6807\u9898\n\tisCollapse:boolean; // \u662F\u5426\u9ED8\u8BA4\u6298\u53E0\n\n\t// Code block wrap div\n\tdiv: HTMLElement;\n\tcontentList: string[];\n\thighLightLines: number[];\n}\n\n// Refer https://developer.mozilla.org/ja/docs/Web/JavaScript/Guide/Regular_Expressions#escaping\nfunction escapeRegExp(str: string): string {\n\treturn str.replace(/[.*+?^=!:${}()|[\\]\\/\\\\]/g, \"\\\\$&\"); // \u4E3A\u7279\u6B8A\u7B26\u53F7\u52A0\u4E0A\u8F6C\u4E49\u7B26\u53F7\"\\\"\n}\n\nexport default class BetterCodeBlock extends Plugin {\n\tsettings: Settings;\n\n\tasync onload() {\n\t\tconsole.log(\"Loading Better Code Block Plugin\");\n\t\tawait this.loadSettings();\n\t\tthis.addSettingTab(new BetterCodeBlockTab(this.app, this));\n\t\tthis.registerMarkdownPostProcessor((el, ctx) => {\n\t\t\tBetterCodeBlocks(el, ctx, this)\n\t\t})\n\t}\n\n\tonunload () {\n\t\tconsole.log('Unloading Better Code Block Plugin');\n\t}\n\t\n\tasync loadSettings() {\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n\t}\n\t\n\tasync saveSettings() {\n\t\tawait this.saveData(this.settings);\n\t}\n}\n\nclass BetterCodeBlockTab extends PluginSettingTab {\n\tplugin: BetterCodeBlock;\n  \n\tconstructor(app: App, plugin: BetterCodeBlock) {\n\t  super(app, plugin);\n\t  this.plugin = plugin;\n\t}\n  \n\tdisplay(): void {\n\t  let { containerEl } = this;\n  \n\t  containerEl.empty();\n\t\n\t  new Setting(containerEl)\n\t\t.setName(\"Exclude language list\")\n\t\t.setDesc(\"Title and line numbers do not apply in these languages, separate by `,`\")\n\t\t.addText(text => text.setPlaceholder('like todoist,other,...')\n\t\t.setValue(this.plugin.settings.excludeLangs.join(','))\n\t\t.onChange(async (value) => {\n\t\t\tthis.plugin.settings.excludeLangs = value.split(',');\n\t\t\tawait this.plugin.saveSettings();\n\t\t})\n\t\t)\n  \n\t  new Setting(containerEl).setName(\"Font color of title\").addText((tc) =>\n\t\ttc\n\t\t  .setPlaceholder(\"Enter a color\")\n\t\t  .setValue(this.plugin.settings.titleFontColor)\n\t\t  .onChange(async (value) => {\n\t\t\tthis.plugin.settings.titleFontColor = value;\n\t\t\tawait this.plugin.saveSettings();\n\t\t  })\n\t  );\n  \n\t  new Setting(containerEl)\n\t\t.setName(\"Background color of title\")\n\t\t.addText((tc) =>\n\t\t  tc\n\t\t\t.setPlaceholder(\"#00000020\")\n\t\t\t.setValue(this.plugin.settings.titleBackgroundColor)\n\t\t\t.onChange(async (value) => {\n\t\t\t  this.plugin.settings.titleBackgroundColor = value;\n\t\t\t  await this.plugin.saveSettings();\n\t\t\t})\n\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t.setName(\"HighLight Color\")\n\t\t.addText((tc) =>\n\t\t  tc\n\t\t\t.setPlaceholder(\"#2d82cc20\")\n\t\t\t.setValue(this.plugin.settings.highLightColor)\n\t\t\t.onChange(async (value) => {\n\t\t\t  this.plugin.settings.highLightColor = value;\n\t\t\t  await this.plugin.saveSettings();\n\t\t\t})\n\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t.setName(\"Show line number\")\n\t\t.addToggle((tc) => \n\t\ttc.setValue(this.plugin.settings.showLineNumber)\n\t\t.onChange(async(value) => {\n\t\t\tthis.plugin.settings.showLineNumber = value;\n\t\t\tawait this.plugin.saveSettings();\n\t\t})\n\t\t)\n\n\t\tnew Setting(containerEl)\n\t\t.setName(\"Show dividing line\")\n\t\t.addToggle((tc) =>\n\t\ttc.setValue(this.plugin.settings.showDividingLine)\n\t\t.onChange(async(value) => {\n\t\t\tthis.plugin.settings.showDividingLine = value;\n\t\t\tawait this.plugin.saveSettings();\n\t\t})\n\t\t)\n\n\t\tnew Setting(containerEl)\n\t\t.setName(\"Show language name in the top right\")\n\t\t.addToggle((tc) =>\n\t\ttc.setValue(this.plugin.settings.showLangNameInTopRight)\n\t\t.onChange(async(value) => {\n\t\t\tthis.plugin.settings.showLangNameInTopRight = value;\n\t\t\tawait this.plugin.saveSettings();\n\t\t})\n\t\t)\n\t}\n  }\n\nexport function BetterCodeBlocks(el: HTMLElement, context: MarkdownPostProcessorContext, plugin: BetterCodeBlock) {\n\tconst settings = plugin.settings\n\t\n\tconst codeElm: HTMLElement = el.querySelector('pre > code')\n\t// only change pre>code\n\tif (!codeElm) {\n\t  return\n\t}\n\n\tlet lang = DEFAULT_LANG\n\t// return when lang is in exclude list\n\tif (plugin.settings.excludeLangs.some(eLangName => codeElm.classList.contains(`language-${eLangName}`))) {\n\t  return\n\t}\n\t\n\tcodeElm.classList.forEach((value, key, parent) => {\n\t  if (LANG_REG.test(value)) {\n\t\tlang = value.replace('language-', '')\n\t\treturn\n\t  }\n\t})\n\n\t// if the code block is not described, return\n\tif(lang == DEFAULT_LANG) {\n\t\treturn\n\t}\n\n\tlet titleRegExp = /TI:\"([^\"]*)\"/i\n\tlet highLightLinesRegExp = /HL:\"([^\"]*)\"/i\n\tlet foldRegExp = /\"FOLD\"/i\n\n\tlet codeBlock = context.getSectionInfo(codeElm)\n\tlet view = app.workspace.getActiveViewOfType(MarkdownView)\n\tlet codeBlockFirstLine = view.editor.getLine(codeBlock.lineStart)\n\n\tlet title: string = \"\"\n\tlet highLightLines: number[] = []\n\tif(codeBlockFirstLine.match(titleRegExp) != null) {\n\t\ttitle = codeBlockFirstLine.match(titleRegExp)[1]\n\t}\n\tif(codeBlockFirstLine.match(highLightLinesRegExp) != null) {\n\t\tlet highLightLinesInfo = codeBlockFirstLine.match(highLightLinesRegExp)[1]\n\t\thighLightLines = analyseHighLightLines(highLightLinesInfo)\n\t}\n\n\tlet isCollapse = false;\n\tif(foldRegExp.test(codeBlockFirstLine)) {\n\t\tisCollapse = true\n\t}\n\n\tconst pre = codeElm.parentElement // code-block-pre__has-linenum\n\tconst div = pre.parentElement // class code-block-wrap\n\n\t/* const { lineStart, lineEnd } = ctx.getSectionInfo(el)\n\tconst lineSize = lineEnd - lineStart - 1 */\n\tconst contentList: string[] = codeElm.textContent.split(LINE_SPLIT_MARK)\n\tconst lineSize = contentList.length - 1\n\n\tconst cbMeta: CodeBlockMeta = { langName: lang, lineSize, pre, code: codeElm, title, isCollapse, div, contentList, highLightLines}\n\n\tconst {showLineNumber} = plugin.settings\n\n\taddCodeTitle(plugin, pre, cbMeta);\n\n\t// add line number\n\tif (showLineNumber) {\n\t\taddLineNumber(plugin, cbMeta)\n\t}\n\n\taddLineHighLight(plugin, pre, cbMeta)\n}\n\nfunction createElement (tagName: string, defaultClassName?: string) {\n\tconst element = document.createElement(tagName)\n\tif (defaultClassName) {\n\t  element.className = defaultClassName\n\t}\n\treturn element\n}\n\nfunction addLineNumber (plugin: BetterCodeBlock, cbMeta: CodeBlockMeta) {\n\tconst { lineSize, pre, div } = cbMeta\n\t// let div position: relative;\n\tdiv.classList.add('code-block-wrap')\n\t// const { fontSize, lineHeight } = window.getComputedStyle(cbMeta.code)\n\tconst lineNumber = createElement('span', 'code-block-linenum-wrap')\n\tlineNumber.style.top = CB_PADDING_TOP;\n\tArray.from({ length: lineSize }, (v, k) => k).forEach(i => {\n\t  const singleLine = createElement('span', 'code-block-linenum')\n\t  // singleLine.style.fontSize = fontSize\n\t  // singleLine.style.lineHeight = lineHeight\n\t  lineNumber.appendChild(singleLine)\n\t})\n\t\n\tif(plugin.settings.showDividingLine) {\n\t\tlineNumber.style.borderRight = \"1px currentColor solid\"\n\t}\n\n\tpre.appendChild(lineNumber)\n\tpre.classList.add('code-block-pre__has-linenum')\n}\n\n\nfunction addCodeTitle (plugin: BetterCodeBlock, wrapperElm: HTMLElement, cbMeta: CodeBlockMeta) {\n\twrapperElm.style.setProperty(\"position\", \"relative\", \"important\");\n\twrapperElm.style.setProperty(\"padding-top\", CB_PADDING_TOP, \"important\");\n\n\twrapperElm\n\t  .querySelectorAll(\".obsidian-embedded-code-title__code-block-title\")\n\t  .forEach((x) => x.remove()); // \u9632\u6296\u52A8\n\n\tlet d = document.createElement(\"pre\");\n\t// d.appendText(cbMeta.title);\n\td.appendText(cbMeta.title)\n\n\tif(cbMeta.isCollapse) {\n\t\td.setAttribute(\"closed\",\"\")\n\t}\n\td.className = \"obsidian-embedded-code-title__code-block-title\";\n\n\tif(plugin.settings.titleFontColor) {\n\t\td.style.setProperty(\"color\", plugin.settings.titleFontColor, \"important\")\n\t}\n\td.style.backgroundColor = plugin.settings.titleBackgroundColor || \"#00000020\";\n\n\tlet collapser = createElement(\"div\",\"collapser\")\n\tlet handle = createElement(\"div\", \"handle\")\n\tcollapser.appendChild(handle)\n\td.appendChild(collapser)\n\n\tif(plugin.settings.showLangNameInTopRight) {\n\t\tlet langName = document.createElement(\"div\"); // \u5728\u53F3\u4FA7\u6DFB\u52A0\u4EE3\u7801\u7C7B\u578B\n\t\tlet langNameString = cbMeta.langName\n\t\tlangNameString = langNameString[0].toUpperCase() + langNameString.slice(1) // \u9996\u5B57\u6BCD\u5927\u5199\n\t\tlangName.appendText(langNameString);\n\t\tlangName.className = \"langName\";\n\t\td.appendChild(langName);\n\t}\n\td.addEventListener('click',function(this) {\n\t\tif(d.hasAttribute(\"closed\")){\n\t\t\td.removeAttribute(\"closed\")\n\t\t} else {\n\t\t\td.setAttribute(\"closed\",'')\n\t\t}\n\t})\n\twrapperElm.prepend(d);\n}\n\nfunction addLineHighLight(plugin: BetterCodeBlock, wrapperElm: HTMLElement, cbMeta: CodeBlockMeta) {\n\tif(cbMeta.highLightLines.length == 0) return\n\n\tlet highLightWrap = document.createElement(\"pre\")\n\thighLightWrap.className = \"code-block-highlight-wrap\"\n\tfor(let i = 0; i < cbMeta.lineSize; i++) {\n\t\tconst singleLine = createElement(\"span\", 'code-block-highlight')\n\t\tif(cbMeta.highLightLines.contains(i+1)) {\n\t\t\tsingleLine.style.backgroundColor = plugin.settings.highLightColor || \"#2d82cc20\"\n\t\t}\n\t\thighLightWrap.appendChild(singleLine)\n\t}\n\n\twrapperElm.appendChild(highLightWrap)\n}\n\nfunction analyseHighLightLines(str: string): number[] {\n\tstr = str.replace(/\\s*/g, \"\") // \u53BB\u9664\u5B57\u7B26\u4E32\u4E2D\u6240\u6709\u7A7A\u683C\n\tconst result: number[] = []\n\n\tlet strs = str.split(\",\")\n\tstrs.forEach(it => {\n\t\tif(/\\w+-\\w+/.test(it)) { // \u5982\u679C\u5339\u914D 1-3 \u8FD9\u6837\u7684\u683C\u5F0F\uFF0C\u4F9D\u6B21\u6DFB\u52A0\u6570\u5B57\n\t\t\tlet left = Number(it.split('-')[0])\n\t\t\tlet right = Number(it.split('-')[1])\n\t\t\tfor(let i = left; i <= right; i++) {\n\t\t\t\tresult.push(i)\n\t\t\t}\n\t\t} else {\n\t\t\tresult.push(Number(it))\n\t\t}\n\t})\n\n\treturn result\n}"],
  "mappings": "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",
  "names": []
}
 +function resizeNumWrapAndHLWrap(el, context) { + setTimeout(function() { + return __async(this, null, function* () { + let codeBlockEl = el.querySelector("pre > code"); + if (!codeBlockEl) + return; + let numWrap = el.querySelector(".code-block-linenum-wrap"); + let highWrap = el.querySelector(".code-block-highlight-wrap"); + let codeBlockInfo = context.getSectionInfo(codeBlockEl); + let view; + let codeBlockLineNum; + let lineStart = 0; + let lineEnd = 0; + if (codeBlockInfo) { + view = app.workspace.getActiveViewOfType(import_obsidian.MarkdownView); + codeBlockLineNum = codeBlockInfo.lineEnd - codeBlockInfo.lineStart - 1; + } else { + return; + } + let span = createElement("span"); + for (let i = 0; i < codeBlockLineNum; i++) { + let oneLineText; + if (view) { + oneLineText = view.editor.getLine(codeBlockInfo.lineStart + i + 1); + } else { + } + span.innerHTML = oneLineText || "0"; + codeBlockEl.appendChild(span); + span.style.display = "block"; + let lineHeight = span.getBoundingClientRect().height + "px"; + let numOneLine = numWrap ? numWrap.childNodes[i] : null; + let hlOneLine = highWrap ? highWrap.childNodes[i] : null; + if (numOneLine) + numOneLine.style.height = lineHeight; + if (hlOneLine) + hlOneLine.style.height = lineHeight; + span.remove(); + } + }); + }, 100); +} +function exportPDF(el, plugin, codeBlockFirstLines, codeBlockSections) { + let codeBlocks = el.querySelectorAll("pre > code"); + codeBlocks.forEach((codeElm, key) => { + let langName = "", title = "", highLightLines = []; + codeElm.classList.forEach((value) => { + if (LANG_REG.test(value)) { + langName = value.replace("language-", ""); + return; + } + }); + if (codeBlockFirstLines[key].match(titleRegExp) != null) { + title = codeBlockFirstLines[key].match(titleRegExp)[1]; + } + if (codeBlockFirstLines[key].match(highLightLinesRegExp) != null) { + let highLightLinesInfo = codeBlockFirstLines[key].match(highLightLinesRegExp)[1]; + highLightLines = analyseHighLightLines(highLightLinesInfo); + } + let lineSize = codeBlockSections[key].position.end.line - codeBlockSections[key].position.start.line - 1; + let cbMeta = { + langName, + lineSize, + pre: codeElm.parentElement, + code: codeElm, + title, + isCollapse: false, + div: codeElm.parentElement.parentElement, + contentList: [], + highLightLines + }; + addCodeTitleWrapper(plugin, codeElm.parentElement, cbMeta); + addCodeTitle(plugin, cbMeta.pre, cbMeta); + if (plugin.settings.showLineNumber) { + addLineNumber(plugin, cbMeta); + } + addLineHighLight(plugin, cbMeta.pre, cbMeta); + }); +} +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["main.ts"],
  "sourcesContent": ["import { linkSync } from 'fs';\nimport { App, Editor, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting, MarkdownPostProcessorContext, Menu, SettingTab, TAbstractFile, TFile, SectionCache, Vault } from 'obsidian';\nimport { json } from 'stream/consumers';\n\nconst DEFAULT_LANG_ATTR = 'language-text'\nconst DEFAULT_LANG = ''\nconst LANG_REG = /^language-/\nconst LINE_SPLIT_MARK = '\\n'\n\nconst titleRegExp = /TI:\"([^\"]*)\"/i\nconst highLightLinesRegExp = /HL:\"([^\"]*)\"/i\nconst foldRegExp = /\"FOLD\"/i\n\nconst CB_PADDING_TOP = \"35px\" // \u4EE3\u7801\u5757\u4E0A\u8FB9\u8DDD\n\ninterface Settings {\n\tsubstitutionTokenForSpace: string;\n\ttitleBackgroundColor: string;\n\ttitleFontColor: string;\n\thighLightColor: string;\n\n\texcludeLangs: string[]; // \u9700\u8981\u6392\u9664\u7684\u8BED\u8A00\n\n\tshowLineNumber: boolean; // \u663E\u793A\u884C\u53F7\n\tshowDividingLine: boolean;\n\tshowLangNameInTopRight: boolean;\n}\n\nconst DEFAULT_SETTINGS: Settings = {\n\tsubstitutionTokenForSpace: undefined,\n\ttitleBackgroundColor: \"#00000020\",\n\ttitleFontColor: undefined,\n\thighLightColor: \"#2d82cc20\",\n\n\texcludeLangs: [],\n\n\tshowLineNumber: true,\n\tshowDividingLine: false,\n\tshowLangNameInTopRight: true\n};\n\ninterface CodeBlockMeta {\n\t// Language name\n\tlangName: string;\n\n\t// Code block total line size\n\tlineSize: number;\n\n\t// Code block 'pre' HTMLElement\n\tpre: HTMLElement;\n\n\t// Code block 'code' HTMLElement\n\tcode: HTMLElement;\n\n\ttitle: string; // \u4EE3\u7801\u5757\u6807\u9898\n\tisCollapse:boolean; // \u662F\u5426\u9ED8\u8BA4\u6298\u53E0\n\n\t// Code block wrap div\n\tdiv: HTMLElement;\n\tcontentList: string[];\n\thighLightLines: number[];\n}\n\n// Refer https://developer.mozilla.org/ja/docs/Web/JavaScript/Guide/Regular_Expressions#escaping\nfunction escapeRegExp(str: string): string {\n\treturn str.replace(/[.*+?^=!:${}()|[\\]\\/\\\\]/g, \"\\\\$&\"); // \u4E3A\u7279\u6B8A\u7B26\u53F7\u52A0\u4E0A\u8F6C\u4E49\u7B26\u53F7\"\\\"\n}\n\nexport default class BetterCodeBlock extends Plugin {\n\tsettings: Settings;\n\n\tasync onload() {\n\t\tconsole.log(\"Loading Better Code Block Plugin\");\n\t\tawait this.loadSettings();\n\t\tthis.addSettingTab(new BetterCodeBlockTab(this.app, this));\n\t\tthis.registerMarkdownPostProcessor((el, ctx) => {\n\t\t\tBetterCodeBlocks(el, ctx, this)\n\t\t\tapp.workspace.on('resize', () => {\n\t\t\t\tresizeNumWrapAndHLWrap(el, ctx)\n\t\t\t})\n\t\t})\n\n\t}\n\n\tonunload () {\n\t\tconsole.log('Unloading Better Code Block Plugin');\n\t}\n\t\n\tasync loadSettings() {\n\t\tthis.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());\n\t}\n\t\n\tasync saveSettings() {\n\t\tawait this.saveData(this.settings);\n\t}\n}\n\nclass BetterCodeBlockTab extends PluginSettingTab {\n\tplugin: BetterCodeBlock;\n  \n\tconstructor(app: App, plugin: BetterCodeBlock) {\n\t  super(app, plugin);\n\t  this.plugin = plugin;\n\t}\n  \n\tdisplay(): void {\n\t  let { containerEl } = this;\n  \n\t  containerEl.empty();\n\t\n\t  new Setting(containerEl)\n\t\t.setName(\"Exclude language list\")\n\t\t.setDesc(\"Title and line numbers do not apply in these languages, separate by `,`\")\n\t\t.addText(text => text.setPlaceholder('like todoist,other,...')\n\t\t.setValue(this.plugin.settings.excludeLangs.join(','))\n\t\t.onChange(async (value) => {\n\t\t\tthis.plugin.settings.excludeLangs = value.split(',');\n\t\t\tawait this.plugin.saveSettings();\n\t\t})\n\t\t)\n  \n\t  new Setting(containerEl).setName(\"Font color of title\").addText((tc) =>\n\t\ttc\n\t\t  .setPlaceholder(\"Enter a color\")\n\t\t  .setValue(this.plugin.settings.titleFontColor)\n\t\t  .onChange(async (value) => {\n\t\t\tthis.plugin.settings.titleFontColor = value;\n\t\t\tawait this.plugin.saveSettings();\n\t\t  })\n\t  );\n  \n\t  new Setting(containerEl)\n\t\t.setName(\"Background color of title\")\n\t\t.addText((tc) =>\n\t\t  tc\n\t\t\t.setPlaceholder(\"#00000020\")\n\t\t\t.setValue(this.plugin.settings.titleBackgroundColor)\n\t\t\t.onChange(async (value) => {\n\t\t\t  this.plugin.settings.titleBackgroundColor = value;\n\t\t\t  await this.plugin.saveSettings();\n\t\t\t})\n\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t.setName(\"HighLight Color\")\n\t\t.addText((tc) =>\n\t\t  tc\n\t\t\t.setPlaceholder(\"#2d82cc20\")\n\t\t\t.setValue(this.plugin.settings.highLightColor)\n\t\t\t.onChange(async (value) => {\n\t\t\t  this.plugin.settings.highLightColor = value;\n\t\t\t  await this.plugin.saveSettings();\n\t\t\t})\n\t\t);\n\n\t\tnew Setting(containerEl)\n\t\t.setName(\"Show line number\")\n\t\t.addToggle((tc) => \n\t\ttc.setValue(this.plugin.settings.showLineNumber)\n\t\t.onChange(async(value) => {\n\t\t\tthis.plugin.settings.showLineNumber = value;\n\t\t\tawait this.plugin.saveSettings();\n\t\t})\n\t\t)\n\n\t\tnew Setting(containerEl)\n\t\t.setName(\"Show dividing line\")\n\t\t.addToggle((tc) =>\n\t\ttc.setValue(this.plugin.settings.showDividingLine)\n\t\t.onChange(async(value) => {\n\t\t\tthis.plugin.settings.showDividingLine = value;\n\t\t\tawait this.plugin.saveSettings();\n\t\t})\n\t\t)\n\n\t\tnew Setting(containerEl)\n\t\t.setName(\"Show language name in the top right\")\n\t\t.addToggle((tc) =>\n\t\ttc.setValue(this.plugin.settings.showLangNameInTopRight)\n\t\t.onChange(async(value) => {\n\t\t\tthis.plugin.settings.showLangNameInTopRight = value;\n\t\t\tawait this.plugin.saveSettings();\n\t\t})\n\t\t)\n\t}\n  }\n\n\nexport async function BetterCodeBlocks(el: HTMLElement, context: MarkdownPostProcessorContext, plugin: BetterCodeBlock) {\n\tconst settings = plugin.settings\n\tconst codeElm: HTMLElement = el.querySelector('pre > code')\n\t// only change pre>code\n\tif (!codeElm) { return }\n\n\tlet lang = DEFAULT_LANG\n\t// return when lang is in exclude list\n\tif (plugin.settings.excludeLangs.some(eLangName => codeElm.classList.contains(`language-${eLangName}`))) {\n\t  return\n\t}\n\t\n\tcodeElm.classList.forEach((value, key, parent) => {\n\t  if (LANG_REG.test(value)) {\n\t\tlang = value.replace('language-', '')\n\t\treturn\n\t  }\n\t})\n\n\t// if the code block is not described, return\n\tif(lang == DEFAULT_LANG) {\n\t\treturn\n\t}\n\n\tlet codeBlock = context.getSectionInfo(codeElm)\n\tlet codeBlockFirstLine = \"\"\n\n\tif(codeBlock) {\n\t\tlet view = app.workspace.getActiveViewOfType(MarkdownView)\n\t\tcodeBlockFirstLine = view.editor.getLine(codeBlock.lineStart)\n\t} else { \n\t\tlet file = app.vault.getAbstractFileByPath(context.sourcePath)\n\t\tlet cache = app.metadataCache.getCache(context.sourcePath)\n\t\tlet fileContent = await app.vault.cachedRead(<TFile> file)\n\t\tlet fileContentLines = fileContent.split(/\\n/g)\n\n\t\tlet codeBlockFirstLines: string[] = []\n\t\tlet codeBlockSections: SectionCache[] = []\n\n\t\tcache.sections?.forEach(async element => {\n\t\t\tif(element.type == \"code\") {\n\t\t\t\tlet lineStart = element.position.start.line\n\t\t\t\tcodeBlockFirstLine = fileContentLines[lineStart]\n\t\t\t\tcodeBlockSections.push(element)\n\t\t\t\tcodeBlockFirstLines.push(codeBlockFirstLine)\n\t\t\t}\n\t\t});\n\t\texportPDF(el, plugin, codeBlockFirstLines, codeBlockSections)\n\t\treturn\n\t}\n\n\tlet title: string = \"\"\n\tlet highLightLines: number[] = []\n\tif(codeBlockFirstLine.match(titleRegExp) != null) {\n\t\ttitle = codeBlockFirstLine.match(titleRegExp)[1]\n\t}\n\tif(codeBlockFirstLine.match(highLightLinesRegExp) != null) {\n\t\tlet highLightLinesInfo = codeBlockFirstLine.match(highLightLinesRegExp)[1]\n\t\thighLightLines = analyseHighLightLines(highLightLinesInfo)\n\t}\n\n\tlet isCollapse = false;\n\tif(foldRegExp.test(codeBlockFirstLine)) {\n\t\tisCollapse = true\n\t}\n\n\tconst pre = codeElm.parentElement // code-block-pre__has-linenum\n\tconst div = pre.parentElement // class code-block-wrap\n\n\t/* const { lineStart, lineEnd } = ctx.getSectionInfo(el)\n\tconst lineSize = lineEnd - lineStart - 1 */\n\tconst contentList: string[] = codeElm.textContent.split(LINE_SPLIT_MARK)\n\tconst lineSize = contentList.length - 1\n\n\tconst cbMeta = { langName: lang, lineSize, pre, code: codeElm, title, isCollapse, div, contentList, highLightLines}\n\n\tconst {showLineNumber} = plugin.settings\n\n\taddCodeTitleWrapper(plugin, pre, cbMeta)\n\t//addIconToTitle(plugin, pre, cbMeta)\n\taddCodeTitle(plugin, pre, cbMeta);\n\n\t// add line number\n\tif (showLineNumber) {\n\t\taddLineNumber(plugin, cbMeta)\n\t}\n\n\taddLineHighLight(plugin, pre, cbMeta)\n\n\tresizeNumWrapAndHLWrap(el,context) // \u8C03\u7528\u4E00\u6B21\u4EE5\u89E3\u51B3\u67D0\u4E9B\u65F6\u5019\u6253\u5F00\u6587\u4EF6\u884C\u9AD8\u672A\u88AB\u91CD\u8BBE\u9AD8\u5EA6\n}\n\nfunction createElement (tagName: string, defaultClassName?: string) {\n\tconst element = document.createElement(tagName)\n\tif (defaultClassName) {\n\t  element.className = defaultClassName\n\t}\n\treturn element\n}\n\nfunction addCodeTitleWrapper(plugin: BetterCodeBlock, preElm: HTMLElement, cbMeta: CodeBlockMeta) {\n\tpreElm.style.setProperty(\"position\", \"relative\", \"important\");\n\tpreElm.style.setProperty(\"padding-top\", CB_PADDING_TOP, \"important\");\n\n\tlet wrapper = document.createElement(\"pre\")\n\tif(cbMeta.isCollapse) {\n\t\twrapper.setAttribute(\"closed\",\"\")\n\t}\n\twrapper.className = \"obsidian-embedded-code-title__code-block-title\"\n\n\twrapper.style.backgroundColor = plugin.settings.titleBackgroundColor || \"#00000020\";\n\n\tlet collapser = createElement(\"div\",\"collapser\")\n\tlet handle = createElement(\"div\", \"handle\")\n\tcollapser.appendChild(handle)\n\twrapper.appendChild(collapser)\n\n\twrapper.addEventListener('click',function(this: any) {\n\t\tif(wrapper.hasAttribute(\"closed\")){\n\t\t\twrapper.removeAttribute(\"closed\")\n\t\t} else {\n\t\t\twrapper.setAttribute(\"closed\",'')\n\t\t}\n\t})\n\n\tpreElm.appendChild(wrapper)\n}\n\nfunction addCodeTitle (plugin: BetterCodeBlock, preElm: HTMLElement, cbMeta: CodeBlockMeta) {\n\tlet wrapper = preElm.querySelector(\".obsidian-embedded-code-title__code-block-title\")\n\n\tlet titleElm = document.createElement(\"div\")\n\ttitleElm.className = \"title\"\n\n\ttitleElm.appendText(cbMeta.title)\n\twrapper.appendChild(titleElm)\n\n\tif(plugin.settings.titleFontColor) {\n\t\ttitleElm.style.setProperty(\"color\", plugin.settings.titleFontColor, \"important\")\n\t}\n\t\n\tif(plugin.settings.showLangNameInTopRight) {\n\t\tlet langName = document.createElement(\"div\"); // \u5728\u53F3\u4FA7\u6DFB\u52A0\u4EE3\u7801\u7C7B\u578B\n\t\tlet langNameString = cbMeta.langName\n\t\tlangNameString = langNameString[0].toUpperCase() + langNameString.slice(1) // \u9996\u5B57\u6BCD\u5927\u5199\n\t\tlangName.appendText(langNameString);\n\t\tlangName.className = \"langName\";\n\t\twrapper.appendChild(langName);\n\t}\n\n\tpreElm.prepend(wrapper);\n\n}\n\nfunction addLineNumber (plugin: BetterCodeBlock, cbMeta: CodeBlockMeta) {\n\tconst { lineSize, pre, div } = cbMeta\n\t// let div position: relative;\n\tdiv.classList.add('code-block-wrap')\n\n\t// const { fontSize, lineHeight } = window.getComputedStyle(cbMeta.code)\n\tconst lineNumber = createElement('span', 'code-block-linenum-wrap')\n\tlineNumber.style.top = CB_PADDING_TOP;\n\tArray.from({ length: lineSize }, (v, k) => k).forEach(i => {\n\t  const singleLine = createElement('span', 'code-block-linenum')\n\t  // singleLine.style.fontSize = fontSize\n\t  // singleLine.style.lineHeight = lineHeight\n\t  lineNumber.appendChild(singleLine)\n\t})\n\t\n\tif(plugin.settings.showDividingLine) {\n\t\tlineNumber.style.borderRight = \"1px currentColor solid\"\n\t}\n\n\tpre.appendChild(lineNumber)\n\tpre.classList.add('code-block-pre__has-linenum')\n}\n\nfunction addLineHighLight(plugin: BetterCodeBlock, preElm: HTMLElement, cbMeta: CodeBlockMeta) {\n\tif(cbMeta.highLightLines.length == 0) return\n\n\tlet highLightWrap = document.createElement(\"pre\")\n\thighLightWrap.className = \"code-block-highlight-wrap\"\n\tfor(let i = 0; i < cbMeta.lineSize; i++) {\n\t\tconst singleLine = createElement(\"span\", 'code-block-highlight')\n\t\tif(cbMeta.highLightLines.contains(i+1)) {\n\t\t\tsingleLine.style.backgroundColor = plugin.settings.highLightColor || \"#2d82cc20\"\n\t\t}\n\t\thighLightWrap.appendChild(singleLine)\n\t}\n\n\tpreElm.appendChild(highLightWrap)\n}\n\nfunction analyseHighLightLines(str: string): number[] {\n\tstr = str.replace(/\\s*/g, \"\") // \u53BB\u9664\u5B57\u7B26\u4E32\u4E2D\u6240\u6709\u7A7A\u683C\n\tconst result: number[] = []\n\n\tlet strs = str.split(\",\")\n\tstrs.forEach(it => {\n\t\tif(/\\w+-\\w+/.test(it)) { // \u5982\u679C\u5339\u914D 1-3 \u8FD9\u6837\u7684\u683C\u5F0F\uFF0C\u4F9D\u6B21\u6DFB\u52A0\u6570\u5B57\n\t\t\tlet left = Number(it.split('-')[0])\n\t\t\tlet right = Number(it.split('-')[1])\n\t\t\tfor(let i = left; i <= right; i++) {\n\t\t\t\tresult.push(i)\n\t\t\t}\n\t\t} else {\n\t\t\tresult.push(Number(it))\n\t\t}\n\t})\n\n\treturn result\n}\n\nfunction addIconToTitle(plugin: BetterCodeBlock, preElm: HTMLElement, cbMeta: CodeBlockMeta) {\n\tlet title = preElm.querySelectorAll(\".obsidian-embedded-code-title__code-block-title\")\n\n\ttitle.forEach(it => {\n\t\tlet iconWrap = createElement(\"div\",\"icon-wrap\")\n\t\tlet icon = document.createElement(\"img\")\n\t\ticon.src = \"\"\n\t\ticonWrap.appendChild(icon)\n\t\tit.appendChild(iconWrap)\n\t})\n\t\n}\n\n// \u5728\u81EA\u52A8\u6362\u884C\u65F6\u5BF9\u6570\u5B57\u548C\u9AD8\u4EAE\u884C\u91CD\u65B0\u8BBE\u7F6E\u9AD8\u5EA6\n// These codes refer to the https://github.com/lijyze/obsidian-advanced-codeblock\nfunction resizeNumWrapAndHLWrap(el: HTMLElement, context: MarkdownPostProcessorContext) {\n\tsetTimeout(async function(){ // \u5EF6\u65F6100\u6BEB\u79D2\u4EE5\u89E3\u51B3\u67D0\u4E9B\u65F6\u5019\u6253\u5F00\u6587\u4EF6\u884C\u9AD8\u672A\u88AB\u91CD\u8BBE\u9AD8\u5EA6\n\t\t// console.log('on esize')\n\t\tlet codeBlockEl : HTMLElement = el.querySelector('pre > code')\n\t\tif(!codeBlockEl) return\n\n\t\tlet numWrap = el.querySelector('.code-block-linenum-wrap')\n\t\tlet highWrap = el.querySelector('.code-block-highlight-wrap')\n\n\t\tlet codeBlockInfo = context.getSectionInfo(codeBlockEl)\n\t\t// let view = app.workspace.getActiveViewOfType(MarkdownView)\n\t\t// let codeBlockLineNum = codeBlockInfo.lineEnd - codeBlockInfo.lineStart - 1 // \u9664\u53BB\u9996\u5C3E\u4E24\u884C\n\t\tlet view\n\t\tlet codeBlockLineNum\n\n\t\tlet lineStart = 0\n\t\tlet lineEnd = 0\n\t\tif(codeBlockInfo) {\n\t\t\tview = app.workspace.getActiveViewOfType(MarkdownView)\n\t\t\tcodeBlockLineNum = codeBlockInfo.lineEnd - codeBlockInfo.lineStart - 1 // \u9664\u53BB\u9996\u5C3E\u4E24\u884C\n\t\t} else {\n\t\t\treturn\n\t\t\t// let file = app.vault.getAbstractFileByPath(context.sourcePath)\n\t\t\t// let cache = app.metadataCache.getCache(context.sourcePath)\n\t\n\t\t\t// cache.sections?.forEach(async element => {\n\t\t\t// \tif(element.type == \"code\") {\n\t\t\t// \t\tlineStart = element.position.start.line\n\t\t\t// \t\tlineEnd = element.position.end.line\n\t\t\t// \t\tcodeBlockLineNum = lineEnd - lineStart - 1\n\t\t\t// \t\treturn\n\t\t\t// \t}\n\t\t\t// });\n\t\t\t// let file = app.vault.getAbstractFileByPath(context.sourcePath)\n\t\t\t// let cache = app.metadataCache.getCache(context.sourcePath)\n\t\t\t// let fileContent = await app.vault.cachedRead(<TFile> file)\n\t\t\t// let fileContentLines = fileContent.split(/\\n/g)\n\t\t}\n\n\t\tlet span = createElement(\"span\")\n\n\t\tfor(let i = 0; i < codeBlockLineNum; i++) {\n\t\t\tlet oneLineText\n\t\t\tif(view){\n\t\t\t\toneLineText = view.editor.getLine(codeBlockInfo.lineStart + i + 1)\n\t\t\t} else {\n\t\t\t\t// oneLineText = fileContentLines[lineStart + 1 + i]\n\t\t\t\t// let file = app.vault.getAbstractFileByPath(context.sourcePath)\n\t\t\t\t// let cache = app.metadataCache.getCache(context.sourcePath)\n\t\t\t\t// let fileContent = await app.vault.cachedRead(<TFile> file)\n\t\t\t\t// let fileContentLines = fileContent.split(/\\n/g)\n\t\t\t\t// oneLineText = fileContentLines[cache.sections]\n\t\t\t}\n\t\t\tspan.innerHTML = oneLineText || \"0\"\n\n\t\t\tcodeBlockEl.appendChild(span)\n\t\t\tspan.style.display = 'block'\n\n\t\t\tlet lineHeight = span.getBoundingClientRect().height + 'px' // \u6D4B\u91CF\u672C\u884C\u6587\u5B57\u7684\u9AD8\u5EA6\n\n\t\t\t// console.log(lineHeight + '    ' + span.getBoundingClientRect().width);\n\t\t\t\n\t\t\tlet numOneLine = numWrap? numWrap.childNodes[i] as HTMLElement : null\n\t\t\tlet hlOneLine = highWrap? highWrap.childNodes[i] as HTMLElement : null\n\n\t\t\tif(numOneLine) numOneLine.style.height = lineHeight;\n\t\t\tif(hlOneLine) hlOneLine.style.height = lineHeight;\n\n\t\t\tspan.remove() // \u6D4B\u91CF\u5B8C\u540E\u5220\u6389\n\t\t}\n\t}, 100)\n}\n\nfunction exportPDF(el: HTMLElement, plugin: BetterCodeBlock, codeBlockFirstLines: string[], codeBlockSections: SectionCache[]) {\n\tlet codeBlocks = el.querySelectorAll('pre > code')\n\tcodeBlocks.forEach((codeElm, key) => {\n\t\tlet langName = \"\", title = \"\", highLightLines: number[] = []\n\t\tcodeElm.classList.forEach(value => {\n\t\t\tif(LANG_REG.test(value)) {\n\t\t\t\tlangName = value.replace('language-', '')\n\t\t\t\treturn\n\t\t\t}\n\t\t})\n\n\t\tif(codeBlockFirstLines[key].match(titleRegExp) != null) {\n\t\t\ttitle = codeBlockFirstLines[key].match(titleRegExp)[1]\n\t\t}\n\t\tif(codeBlockFirstLines[key].match(highLightLinesRegExp) != null) {\n\t\t\tlet highLightLinesInfo = codeBlockFirstLines[key].match(highLightLinesRegExp)[1]\n\t\t\thighLightLines = analyseHighLightLines(highLightLinesInfo)\n\t\t}\n\n\t\tlet lineSize = codeBlockSections[key].position.end.line - codeBlockSections[key].position.start.line - 1\n\n\t\tlet cbMeta: CodeBlockMeta = {\n\t\t\tlangName: langName,\n\t\t\tlineSize: lineSize,\n\t\t\tpre: codeElm.parentElement,\n\t\t\tcode: codeElm as HTMLElement,\n\t\t\ttitle: title,\n\t\t\tisCollapse: false,\n\t\t\tdiv: codeElm.parentElement.parentElement,\n\t\t\tcontentList: [],\n\t\t\thighLightLines: highLightLines\n\t\t}\n\t\taddCodeTitleWrapper(plugin, codeElm.parentElement, cbMeta) // \u5BFC\u51FA\u53D6\u6D88\u4EE3\u7801\u5757\u6298\u53E0\n\t\taddCodeTitle(plugin, cbMeta.pre, cbMeta)\n\t\tif(plugin.settings.showLineNumber) {\n\t\t\taddLineNumber(plugin, cbMeta)\n\t\t}\n\t\taddLineHighLight(plugin, cbMeta.pre, cbMeta)\n\t})\n}"],
  "mappings": "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",
  "names": []
}
 diff --git a/main.ts b/main.ts index 2efa67e..d4349f2 100644 --- a/main.ts +++ b/main.ts @@ -1,11 +1,16 @@ import { linkSync } from 'fs'; -import { App, Editor, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting, MarkdownPostProcessorContext, Menu, SettingTab, TAbstractFile, TFile } from 'obsidian'; +import { App, Editor, MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting, MarkdownPostProcessorContext, Menu, SettingTab, TAbstractFile, TFile, SectionCache, Vault } from 'obsidian'; +import { json } from 'stream/consumers'; const DEFAULT_LANG_ATTR = 'language-text' const DEFAULT_LANG = '' const LANG_REG = /^language-/ const LINE_SPLIT_MARK = '\n' +const titleRegExp = /TI:"([^"]*)"/i +const highLightLinesRegExp = /HL:"([^"]*)"/i +const foldRegExp = /"FOLD"/i + const CB_PADDING_TOP = "35px" // 代码块上边距 interface Settings { @@ -70,7 +75,11 @@ export default class BetterCodeBlock extends Plugin { this.addSettingTab(new BetterCodeBlockTab(this.app, this)); this.registerMarkdownPostProcessor((el, ctx) => { BetterCodeBlocks(el, ctx, this) + app.workspace.on('resize', () => { + resizeNumWrapAndHLWrap(el, ctx) + }) }) + } onunload () { @@ -176,14 +185,12 @@ class BetterCodeBlockTab extends PluginSettingTab { } } -export function BetterCodeBlocks(el: HTMLElement, context: MarkdownPostProcessorContext, plugin: BetterCodeBlock) { + +export async function BetterCodeBlocks(el: HTMLElement, context: MarkdownPostProcessorContext, plugin: BetterCodeBlock) { const settings = plugin.settings - const codeElm: HTMLElement = el.querySelector('pre > code') // only change pre>code - if (!codeElm) { - return - } + if (!codeElm) { return } let lang = DEFAULT_LANG // return when lang is in exclude list @@ -203,13 +210,32 @@ export function BetterCodeBlocks(el: HTMLElement, context: MarkdownPostProcessor return } - let titleRegExp = /TI:"([^"]*)"/i - let highLightLinesRegExp = /HL:"([^"]*)"/i - let foldRegExp = /"FOLD"/i - let codeBlock = context.getSectionInfo(codeElm) - let view = app.workspace.getActiveViewOfType(MarkdownView) - let codeBlockFirstLine = view.editor.getLine(codeBlock.lineStart) + let codeBlockFirstLine = "" + + if(codeBlock) { + let view = app.workspace.getActiveViewOfType(MarkdownView) + codeBlockFirstLine = view.editor.getLine(codeBlock.lineStart) + } else { + let file = app.vault.getAbstractFileByPath(context.sourcePath) + let cache = app.metadataCache.getCache(context.sourcePath) + let fileContent = await app.vault.cachedRead( file) + let fileContentLines = fileContent.split(/\n/g) + + let codeBlockFirstLines: string[] = [] + let codeBlockSections: SectionCache[] = [] + + cache.sections?.forEach(async element => { + if(element.type == "code") { + let lineStart = element.position.start.line + codeBlockFirstLine = fileContentLines[lineStart] + codeBlockSections.push(element) + codeBlockFirstLines.push(codeBlockFirstLine) + } + }); + exportPDF(el, plugin, codeBlockFirstLines, codeBlockSections) + return + } let title: string = "" let highLightLines: number[] = [] @@ -234,10 +260,12 @@ export function BetterCodeBlocks(el: HTMLElement, context: MarkdownPostProcessor const contentList: string[] = codeElm.textContent.split(LINE_SPLIT_MARK) const lineSize = contentList.length - 1 - const cbMeta: CodeBlockMeta = { langName: lang, lineSize, pre, code: codeElm, title, isCollapse, div, contentList, highLightLines} + const cbMeta = { langName: lang, lineSize, pre, code: codeElm, title, isCollapse, div, contentList, highLightLines} const {showLineNumber} = plugin.settings + addCodeTitleWrapper(plugin, pre, cbMeta) + //addIconToTitle(plugin, pre, cbMeta) addCodeTitle(plugin, pre, cbMeta); // add line number @@ -246,6 +274,8 @@ export function BetterCodeBlocks(el: HTMLElement, context: MarkdownPostProcessor } addLineHighLight(plugin, pre, cbMeta) + + resizeNumWrapAndHLWrap(el,context) // 调用一次以解决某些时候打开文件行高未被重设高度 } function createElement (tagName: string, defaultClassName?: string) { @@ -256,10 +286,65 @@ function createElement (tagName: string, defaultClassName?: string) { return element } +function addCodeTitleWrapper(plugin: BetterCodeBlock, preElm: HTMLElement, cbMeta: CodeBlockMeta) { + preElm.style.setProperty("position", "relative", "important"); + preElm.style.setProperty("padding-top", CB_PADDING_TOP, "important"); + + let wrapper = document.createElement("pre") + if(cbMeta.isCollapse) { + wrapper.setAttribute("closed","") + } + wrapper.className = "obsidian-embedded-code-title__code-block-title" + + wrapper.style.backgroundColor = plugin.settings.titleBackgroundColor || "#00000020"; + + let collapser = createElement("div","collapser") + let handle = createElement("div", "handle") + collapser.appendChild(handle) + wrapper.appendChild(collapser) + + wrapper.addEventListener('click',function(this: any) { + if(wrapper.hasAttribute("closed")){ + wrapper.removeAttribute("closed") + } else { + wrapper.setAttribute("closed",'') + } + }) + + preElm.appendChild(wrapper) +} + +function addCodeTitle (plugin: BetterCodeBlock, preElm: HTMLElement, cbMeta: CodeBlockMeta) { + let wrapper = preElm.querySelector(".obsidian-embedded-code-title__code-block-title") + + let titleElm = document.createElement("div") + titleElm.className = "title" + + titleElm.appendText(cbMeta.title) + wrapper.appendChild(titleElm) + + if(plugin.settings.titleFontColor) { + titleElm.style.setProperty("color", plugin.settings.titleFontColor, "important") + } + + if(plugin.settings.showLangNameInTopRight) { + let langName = document.createElement("div"); // 在右侧添加代码类型 + let langNameString = cbMeta.langName + langNameString = langNameString[0].toUpperCase() + langNameString.slice(1) // 首字母大写 + langName.appendText(langNameString); + langName.className = "langName"; + wrapper.appendChild(langName); + } + + preElm.prepend(wrapper); + +} + function addLineNumber (plugin: BetterCodeBlock, cbMeta: CodeBlockMeta) { const { lineSize, pre, div } = cbMeta // let div position: relative; div.classList.add('code-block-wrap') + // const { fontSize, lineHeight } = window.getComputedStyle(cbMeta.code) const lineNumber = createElement('span', 'code-block-linenum-wrap') lineNumber.style.top = CB_PADDING_TOP; @@ -278,53 +363,7 @@ function addLineNumber (plugin: BetterCodeBlock, cbMeta: CodeBlockMeta) { pre.classList.add('code-block-pre__has-linenum') } - -function addCodeTitle (plugin: BetterCodeBlock, wrapperElm: HTMLElement, cbMeta: CodeBlockMeta) { - wrapperElm.style.setProperty("position", "relative", "important"); - wrapperElm.style.setProperty("padding-top", CB_PADDING_TOP, "important"); - - wrapperElm - .querySelectorAll(".obsidian-embedded-code-title__code-block-title") - .forEach((x) => x.remove()); // 防抖动 - - let d = document.createElement("pre"); - // d.appendText(cbMeta.title); - d.appendText(cbMeta.title) - - if(cbMeta.isCollapse) { - d.setAttribute("closed","") - } - d.className = "obsidian-embedded-code-title__code-block-title"; - - if(plugin.settings.titleFontColor) { - d.style.setProperty("color", plugin.settings.titleFontColor, "important") - } - d.style.backgroundColor = plugin.settings.titleBackgroundColor || "#00000020"; - - let collapser = createElement("div","collapser") - let handle = createElement("div", "handle") - collapser.appendChild(handle) - d.appendChild(collapser) - - if(plugin.settings.showLangNameInTopRight) { - let langName = document.createElement("div"); // 在右侧添加代码类型 - let langNameString = cbMeta.langName - langNameString = langNameString[0].toUpperCase() + langNameString.slice(1) // 首字母大写 - langName.appendText(langNameString); - langName.className = "langName"; - d.appendChild(langName); - } - d.addEventListener('click',function(this) { - if(d.hasAttribute("closed")){ - d.removeAttribute("closed") - } else { - d.setAttribute("closed",'') - } - }) - wrapperElm.prepend(d); -} - -function addLineHighLight(plugin: BetterCodeBlock, wrapperElm: HTMLElement, cbMeta: CodeBlockMeta) { +function addLineHighLight(plugin: BetterCodeBlock, preElm: HTMLElement, cbMeta: CodeBlockMeta) { if(cbMeta.highLightLines.length == 0) return let highLightWrap = document.createElement("pre") @@ -337,7 +376,7 @@ function addLineHighLight(plugin: BetterCodeBlock, wrapperElm: HTMLElement, cbMe highLightWrap.appendChild(singleLine) } - wrapperElm.appendChild(highLightWrap) + preElm.appendChild(highLightWrap) } function analyseHighLightLines(str: string): number[] { @@ -358,4 +397,133 @@ function analyseHighLightLines(str: string): number[] { }) return result +} + +function addIconToTitle(plugin: BetterCodeBlock, preElm: HTMLElement, cbMeta: CodeBlockMeta) { + let title = preElm.querySelectorAll(".obsidian-embedded-code-title__code-block-title") + + title.forEach(it => { + let iconWrap = createElement("div","icon-wrap") + let icon = document.createElement("img") + icon.src = "" + iconWrap.appendChild(icon) + it.appendChild(iconWrap) + }) + +} + +// 在自动换行时对数字和高亮行重新设置高度 +// These codes refer to the https://github.com/lijyze/obsidian-advanced-codeblock +function resizeNumWrapAndHLWrap(el: HTMLElement, context: MarkdownPostProcessorContext) { + setTimeout(async function(){ // 延时100毫秒以解决某些时候打开文件行高未被重设高度 + // console.log('on esize') + let codeBlockEl : HTMLElement = el.querySelector('pre > code') + if(!codeBlockEl) return + + let numWrap = el.querySelector('.code-block-linenum-wrap') + let highWrap = el.querySelector('.code-block-highlight-wrap') + + let codeBlockInfo = context.getSectionInfo(codeBlockEl) + // let view = app.workspace.getActiveViewOfType(MarkdownView) + // let codeBlockLineNum = codeBlockInfo.lineEnd - codeBlockInfo.lineStart - 1 // 除去首尾两行 + let view + let codeBlockLineNum + + let lineStart = 0 + let lineEnd = 0 + if(codeBlockInfo) { + view = app.workspace.getActiveViewOfType(MarkdownView) + codeBlockLineNum = codeBlockInfo.lineEnd - codeBlockInfo.lineStart - 1 // 除去首尾两行 + } else { + return + // let file = app.vault.getAbstractFileByPath(context.sourcePath) + // let cache = app.metadataCache.getCache(context.sourcePath) + + // cache.sections?.forEach(async element => { + // if(element.type == "code") { + // lineStart = element.position.start.line + // lineEnd = element.position.end.line + // codeBlockLineNum = lineEnd - lineStart - 1 + // return + // } + // }); + // let file = app.vault.getAbstractFileByPath(context.sourcePath) + // let cache = app.metadataCache.getCache(context.sourcePath) + // let fileContent = await app.vault.cachedRead( file) + // let fileContentLines = fileContent.split(/\n/g) + } + + let span = createElement("span") + + for(let i = 0; i < codeBlockLineNum; i++) { + let oneLineText + if(view){ + oneLineText = view.editor.getLine(codeBlockInfo.lineStart + i + 1) + } else { + // oneLineText = fileContentLines[lineStart + 1 + i] + // let file = app.vault.getAbstractFileByPath(context.sourcePath) + // let cache = app.metadataCache.getCache(context.sourcePath) + // let fileContent = await app.vault.cachedRead( file) + // let fileContentLines = fileContent.split(/\n/g) + // oneLineText = fileContentLines[cache.sections] + } + span.innerHTML = oneLineText || "0" + + codeBlockEl.appendChild(span) + span.style.display = 'block' + + let lineHeight = span.getBoundingClientRect().height + 'px' // 测量本行文字的高度 + + // console.log(lineHeight + ' ' + span.getBoundingClientRect().width); + + let numOneLine = numWrap? numWrap.childNodes[i] as HTMLElement : null + let hlOneLine = highWrap? highWrap.childNodes[i] as HTMLElement : null + + if(numOneLine) numOneLine.style.height = lineHeight; + if(hlOneLine) hlOneLine.style.height = lineHeight; + + span.remove() // 测量完后删掉 + } + }, 100) +} + +function exportPDF(el: HTMLElement, plugin: BetterCodeBlock, codeBlockFirstLines: string[], codeBlockSections: SectionCache[]) { + let codeBlocks = el.querySelectorAll('pre > code') + codeBlocks.forEach((codeElm, key) => { + let langName = "", title = "", highLightLines: number[] = [] + codeElm.classList.forEach(value => { + if(LANG_REG.test(value)) { + langName = value.replace('language-', '') + return + } + }) + + if(codeBlockFirstLines[key].match(titleRegExp) != null) { + title = codeBlockFirstLines[key].match(titleRegExp)[1] + } + if(codeBlockFirstLines[key].match(highLightLinesRegExp) != null) { + let highLightLinesInfo = codeBlockFirstLines[key].match(highLightLinesRegExp)[1] + highLightLines = analyseHighLightLines(highLightLinesInfo) + } + + let lineSize = codeBlockSections[key].position.end.line - codeBlockSections[key].position.start.line - 1 + + let cbMeta: CodeBlockMeta = { + langName: langName, + lineSize: lineSize, + pre: codeElm.parentElement, + code: codeElm as HTMLElement, + title: title, + isCollapse: false, + div: codeElm.parentElement.parentElement, + contentList: [], + highLightLines: highLightLines + } + addCodeTitleWrapper(plugin, codeElm.parentElement, cbMeta) // 导出取消代码块折叠 + addCodeTitle(plugin, cbMeta.pre, cbMeta) + if(plugin.settings.showLineNumber) { + addLineNumber(plugin, cbMeta) + } + addLineHighLight(plugin, cbMeta.pre, cbMeta) + }) } \ No newline at end of file diff --git a/manifest.json b/manifest.json index 99396ba..860272f 100644 --- a/manifest.json +++ b/manifest.json @@ -1,7 +1,7 @@ { "id": "obsidian-better-codeblock", "name": "Better CodeBlock", - "version": "1.0.6", + "version": "1.0.7", "minAppVersion": "0.12.0", "description": "Add title, line number to Obsidian code block", "author": "StarGrey", diff --git a/styles.css b/styles.css index d9e687b..3c9cc84 100644 --- a/styles.css +++ b/styles.css @@ -144,3 +144,32 @@ pre[class*=language-] .code-block-highlight-wrap span { .obsidian-embedded-code-title__code-block-title[closed] + code + span + span span{ visibility: hidden; } + +.obsidian-embedded-code-title__code-block-title > .title { + display: inline-block; + position: relative; + margin-left: 5px !important; + margin: 0; + padding: 0; + + top: 50%; + transform: translateY(-50%); +} + +/* .obsidian-embedded-code-title__code-block-title > .icon-wrap { + display: inline-block; + position: relative; + width: 20px; + height: 20px; + background-position: center; + + top: 50%; + transform: translateY(-50%); +} */ + +.code-block-wrap > pre > code[class*=language-]{ + padding: 0em 0em 0em 0em !important; + /* padding-top: 0 !important; */ + font-size: var(--editor-font-size) !important; + line-height: 1.5em !important; +} \ No newline at end of file