Merge pull request #50 from gera2ld/master

Update markmap and fix render issues

Author: neatc0der

README.md

@@ -72,26 +72,27 @@ plugins:
       base_path: docs
       encoding: utf-8
       file_extension: .mm.md
-      d3_version: 6.7.0
-      lib_version: 0.14.1
-      view_version: 0.14.0
+      d3_version: 7
+      lib_version: 0.15.3
+      view_version: 0.15.3
 ```
 
 In addition, feel free to define your favourite source urls like this:
 
 ```yaml
+plugins:
+  - markmap:
+      # disable the default assets first
+      d3_version: ''
+      lib_version: ''
+      view_version: ''
+
 extra_javascript:
-  - https://unpkg.com/d3@6.7.0/dist/d3.min.js
-  - https://unpkg.com/markmap-lib@0.14.1/dist/browser/index.min.js
-  - https://unpkg.com/markmap-view@0.14.0/dist/index.min.js
+  - https://unpkg.com/d3@7/dist/d3.min.js
+  - https://unpkg.com/markmap-lib@0.15.3/dist/browser/index.js
+  - https://unpkg.com/markmap-view@0.15.3/dist/browser/index.js
 ```
 
-:warning: The urls need to contain one of these keywords to be considered as deviation from default:
-
-* `markmap-d3`
-* `markmap-lib`
-* `markmap-view`
-
 ## Troubleshooting
 
 ### Nav tree lists markmaps

changelog/v2.4.0.md

@@ -0,0 +1,5 @@
+# v2.4.0
+
+* Update markmap libraries to `0.15.x`
+* Support custom static assets
+* Allow removing the default assets

mkdocs_markmap/__meta__.py

@@ -1,8 +1,8 @@
-PACKAGE_NAME: str = 'mkdocs_markmap'
-PROJECT_NAME: str = PACKAGE_NAME.replace('_', '-')
-PROJECT_VERSION: str = '2.3.0'
+PACKAGE_NAME: str = "mkdocs_markmap"
+PROJECT_NAME: str = PACKAGE_NAME.replace("_", "-")
+PROJECT_VERSION: str = "2.4.0"
 
-OWNER: str = 'neatc0der'
-ORGANISATION: str = 'markmap'
-REPOSITORY_NAME: str = f'{ORGANISATION}/{PROJECT_NAME}'
-REPOSITORY_URL: str = f'https://github.com/{REPOSITORY_NAME}'
+OWNER: str = "neatc0der"
+ORGANISATION: str = "markmap"
+REPOSITORY_NAME: str = f"{ORGANISATION}/{PROJECT_NAME}"
+REPOSITORY_URL: str = f"https://github.com/{REPOSITORY_NAME}"

mkdocs_markmap/defaults.py

@@ -9,23 +9,23 @@ class JsModuleConfig(object):
     uri: str = attr.attrib()
 
 D3_LIB: JsModuleConfig = JsModuleConfig(
-    version='6.7.0',
-    uri='https://unpkg.com/d3@{}/dist/d3.min.js',
+    version="7",
+    uri="https://unpkg.com/d3@{}",
 )
 
 MARKMAP_LIB: JsModuleConfig = JsModuleConfig(
-    version='0.14.1',
-    uri='https://unpkg.com/markmap-lib@{}/dist/browser/index.min.js',
+    version="0.15.4",
+    uri="https://unpkg.com/markmap-lib@{}",
 )
 
 MARKMAP_VIEW: JsModuleConfig = JsModuleConfig(
-    version='0.14.0',
-    uri='https://unpkg.com/markmap-view@{}/dist/index.min.js',
+    version="0.15.4",
+    uri="https://unpkg.com/markmap-view@{}",
 )
 
 
 MARKMAP: Dict[str, JsModuleConfig] = {
-    'd3': D3_LIB,
-    'lib': MARKMAP_LIB,
-    'view': MARKMAP_VIEW,
+    "d3": D3_LIB,
+    "lib": MARKMAP_LIB,
+    "view": MARKMAP_VIEW,
 }

mkdocs_markmap/extension.py

@@ -9,10 +9,10 @@
 from markdown.preprocessors import Preprocessor
 
 
-log = logging.getLogger('mkdocs.markmap')
+log = logging.getLogger("mkdocs.markmap")
 
 
-INCLUDE_SYNTAX = re.compile(r'\{!\s*(?P<path>.+?)\s*!\}')
+INCLUDE_SYNTAX = re.compile(r"\{!\s*(?P<path>.+?)\s*!\}")
 
 
 class MarkmapPreprocessor(Preprocessor):
@@ -22,9 +22,9 @@ class MarkmapPreprocessor(Preprocessor):
 
     def __init__(self, md: Markdown, config: Dict[str, str]):
         super(MarkmapPreprocessor, self).__init__(md)
-        self.base_path: str = config['base_path']
-        self.encoding: str = config['encoding']
-        self.file_extension: str = config['file_extension']
+        self.base_path: str = config["base_path"]
+        self.encoding: str = config["encoding"]
+        self.file_extension: str = config["file_extension"]
 
     def run(self, lines: List[str]) -> List[str]:
         done: bool = False
@@ -35,7 +35,7 @@ def run(self, lines: List[str]) -> List[str]:
                 if match is None:
                     continue
 
-                path: Path = Path(match.group('path'))
+                path: Path = Path(match.group("path"))
                 if not path.name.lower().endswith(self.file_extension):
                     continue
 
@@ -48,25 +48,25 @@ def run(self, lines: List[str]) -> List[str]:
 
                 included_paths.append(path)
                 try:
-                    with open(path, 'r', encoding=self.encoding) as r:
+                    with open(path, "r", encoding=self.encoding) as r:
                         markmap: List[str] = r.readlines()
 
                 except Exception as e:
-                    log.error('unable to include file {}. Ignoring statement. Error: {}'.format(path, e))
-                    lines[loc] = INCLUDE_SYNTAX.sub('',line)
+                    log.error("unable to include file {}. Ignoring statement. Error: {}".format(path, e))
+                    lines[loc] = INCLUDE_SYNTAX.sub("",line)
                     break
 
                 line_split: List[str] = INCLUDE_SYNTAX.split(line)
                 if len(markmap) == 0:
-                    markmap.append('')
+                    markmap.append("")
                 else:
-                    markmap.insert(0, '```markmap')
-                    markmap.append('```')
+                    markmap.insert(0, "```markmap")
+                    markmap.append("```")
 
-                if line_split[0].strip() != '':
+                if line_split[0].strip() != "":
                     markmap.insert(0, line_split[0])
 
-                if line_split[2].strip() != '':
+                if line_split[2].strip() != "":
                     markmap.append(line_split[2])
 
                 lines = lines[:loc] + markmap + lines[loc+1:]
@@ -80,9 +80,9 @@ def run(self, lines: List[str]) -> List[str]:
 
 class MarkmapExtension(Extension):
     config_defaults: Dict[str, str] = {
-        'base_path': ['docs', 'Default location from which to evaluate relative paths for the include statement.'],
-        'encoding': ['utf-8', 'Encoding of the files used by the include statement.'],
-        'file_extension': ['.mm.md', 'File extension of mindmap files'],
+        "base_path": ["docs", "Default location from which to evaluate relative paths for the include statement."],
+        "encoding": ["utf-8", "Encoding of the files used by the include statement."],
+        "file_extension": [".mm.md", "File extension of mindmap files"],
     }
 
     def __init__(self, **configs: Dict[str, str]):
@@ -91,21 +91,21 @@ def __init__(self, **configs: Dict[str, str]):
             self.setConfig(key, value)
 
     def extendMarkdown(self, md: Markdown) -> None:
-        md.preprocessors.register(MarkmapPreprocessor(md, self.getConfigs()), 'include_markmap', 102)
+        md.preprocessors.register(MarkmapPreprocessor(md, self.getConfigs()), "include_markmap", 102)
         for extension in md.registeredExtensions:
-            if extension.__class__.__name__ == 'SuperFencesCodeExtension':
-                log.info(f'superfences detected by markmap')
+            if extension.__class__.__name__ == "SuperFencesCodeExtension":
+                log.info(f"superfences detected by markmap")
                 try:
                     from pymdownx.superfences import default_validator, fence_code_format, _formatter, _validator
                     extension.extend_super_fences(
-                        'markmap',
-                        partial(_formatter, class_name='language-markmap', _fmt=fence_code_format),
+                        "markmap",
+                        partial(_formatter, class_name="language-markmap", _fmt=fence_code_format),
                         partial(_validator, validator=default_validator)
                     )
                     break
 
                 except ImportError as e:
-                    log.warning(f'markmap detected pymdownx.superfences, but import is not working: {e}')
+                    log.warning(f"markmap detected pymdownx.superfences, but import is not working: {e}")
 
                 except Exception as e:
-                    log.error(f'unexpected error: {e}')
+                    log.error(f"unexpected error: {e}")

mkdocs_markmap/plugin.py

@@ -1,25 +1,28 @@
 import logging
-from mkdocs_markmap.extension import MarkmapExtension
-import re
 from pathlib import Path
+import re
 from typing import Dict, Tuple
 
 from bs4 import BeautifulSoup, ResultSet, Tag
-from mkdocs.plugins import BasePlugin
-from mkdocs.structure.pages import Page
+
 from mkdocs.config.base import Config, load_config
 from mkdocs.config.config_options import Type as PluginType
+from mkdocs.plugins import BasePlugin
+from mkdocs.structure.pages import Page
+from mkdocs_markmap.extension import MarkmapExtension
 
 from .defaults import MARKMAP
 from .utils import download
 
 
-log = logging.getLogger('mkdocs.markmap')
+log = logging.getLogger("mkdocs.markmap")
 
 
-STATICS_PATH: Path = Path(__file__).parent / 'static_files'
-STYLE_PATH: Path = STATICS_PATH / 'mkdocs-markmap.css'
-SCRIPT_PATH: Path = STATICS_PATH / 'mkdocs-markmap.js'
+STATICS_PATH: Path = Path(__file__).parent / "static_files"
+STYLE_PATH: Path = STATICS_PATH / "mkdocs-markmap.css"
+SCRIPT_PATH: Path = STATICS_PATH / "mkdocs-markmap.js"
+
+VERSION_KEY = "{name}_version"
 
 
 class MarkmapPlugin(BasePlugin):
@@ -28,12 +31,12 @@ class MarkmapPlugin(BasePlugin):
     """
     config_scheme: Tuple[Tuple[str, PluginType]] = (
         *(
-            (f'{name}_version', PluginType(str, default=module.version))
+            (VERSION_KEY.format(name=name), PluginType(str, default=module.version))
             for name, module in MARKMAP.items()
         ),
-        ('base_path', PluginType(str, default='docs')),
-        ('encoding', PluginType(str, default='utf-8')),
-        ('file_extension', PluginType(str, default='.mm.md')),
+        ("base_path", PluginType(str, default="docs")),
+        ("encoding", PluginType(str, default="utf-8")),
+        ("file_extension", PluginType(str, default=".mm.md")),
     )
 
     def __init__(self):
@@ -44,96 +47,86 @@ def markmap(self) -> Dict[str, str]:
         """
         Provides all markmap libraries defined in mkdocs.yml (if any)
         """
-        if self._markmap is None:            
-            extra_javascript = self.config.get('extra_javascript', [])
+        if self._markmap is None:
             self._markmap: Dict[str, str] = {}
-            for uri in extra_javascript:
-                for name in MARKMAP.keys():
-                    if f'markmap-{name}' in uri.lower():
-                        self._markmap[name] = uri
-
             for name, module in MARKMAP.items():
-                if name not in self._markmap:
-                    self._markmap[name] = module.uri.format(self.config[f'{name}_version'])
+                if self.config[VERSION_KEY.format(name=name)]:
+                    self._markmap[name] = module.uri.format(self.config[VERSION_KEY.format(name=name)])
 
         return self._markmap
 
     def _load_scripts(self, soup: BeautifulSoup, script_base_url: str, js_path: Path) -> None:
         for script_url in self.markmap.values():
             if script_url.lower().startswith("http"):
                 try:
-                    src: str = script_base_url + download(js_path, script_url)
+                    src: str = script_base_url + download(js_path, script_url, extname=".js")
                 except Exception as e:
-                    log.error(f'unable to download script: {script_url}')
+                    log.error(f"unable to download script: {script_url}")
                     src = script_url
 
             else:
                 log.info(f"static script detected: {script_url}")
                 src = script_url
-            
-            script: Tag = soup.new_tag('script', src=src, type='text/javascript')
+
+            script: Tag = soup.new_tag("script", src=src, type="text/javascript")
             soup.head.append(script)
 
     @staticmethod
     def _add_statics(soup: BeautifulSoup):
         statics = (
-            (STYLE_PATH, 'style', 'text/css', 'head'),
-            (SCRIPT_PATH, 'script', 'text/javascript', 'body'),
+            (STYLE_PATH, "style", "text/css", "head"),
+            (SCRIPT_PATH, "script", "text/javascript", "body"),
         )
 
         for path, tag_name, text_type, attribute in statics:
             tag: Tag = soup.new_tag(tag_name, type=text_type)
-            with open(path, 'r') as fp:
+            with open(path, "r") as fp:
                 tag.string = fp.read()
-            getattr(soup, attribute).append(tag)    
+            getattr(soup, attribute).append(tag)
 
     def on_config(self, config: Config) -> Config:
-        config['markdown_extensions'].append('markmap')
-        config['mdx_configs']['markmap'] = {
+        config["markdown_extensions"].append("markmap")
+        config["mdx_configs"]["markmap"] = {
             key: value
-            for key, value in config['plugins'].get('markmap').config.items()
+            for key, value in config["plugins"].get("markmap").config.items()
             if key in MarkmapExtension.config_defaults
         }
-        self.config['extra_javascript'] = config.get('extra_javascript', [])
+        self.config["extra_javascript"] = config.get("extra_javascript", [])
 
         return config
 
     def on_post_page(self, html: str, page: Page, config: Config, **kwargs) -> str:
-        if not getattr(page, '_found_markmap', False):
+        if not getattr(page, "_found_markmap", False):
             log.info(f"no markmap found: {page.file.name}")
             return html
 
-        soup: BeautifulSoup = BeautifulSoup(html, 'html.parser')
-        script_base_url: str = re.sub(r'[^/]+?/', '../', re.sub(r'/+?', '/', page.url)) + 'js/'
-        js_path: Path = Path(config['site_dir']) / 'js'
+        soup: BeautifulSoup = BeautifulSoup(html, "html.parser")
+        script_base_url: str = re.sub(r"[^/]+?/", "../", re.sub(r"/+?", "/", page.url)) + "js/"
+        js_path: Path = Path(config["site_dir"]) / "js"
         self._load_scripts(soup, script_base_url, js_path)
         self._add_statics(soup)
 
         return str(soup)
 
     def on_page_content(self, html: str, page: Page, **kwargs) -> str:
-        soup: BeautifulSoup = BeautifulSoup(html, 'html.parser')
-        markmaps: ResultSet = soup.find_all(class_='language-markmap')
-        setattr(page, '_found_markmap', any(markmaps))
+        soup: BeautifulSoup = BeautifulSoup(html, "html.parser")
+        markmaps: ResultSet = soup.find_all(class_="language-markmap")
+        setattr(page, "_found_markmap", any(markmaps))
 
         for index, markmap in enumerate(markmaps):
             markmap: Tag
-            tag_id: str = f'markmap-{index}'
+            tag_id: str = f"markmap-{index}"
             pre: Tag
             code: Tag
-            if markmap.name == 'pre':
+            if markmap.name == "pre":
                 pre = markmap
-                code = markmap.findChild('code')
+                code = markmap.findChild("code")
             else:
                 pre = markmap.parent
                 code = markmap
-            pre.name = 'div'
-            pre['class'] = pre.get('class', []) + ['mkdocs-markmap']
-            pre['data-markdown'] = code.text.replace('\n', '
')
-            code.replaceWith(soup.new_tag(
-                'svg', 
-                id=tag_id, 
-                attrs={'class': 'markmap'},
-            ))
+            pre.name = "div"
+            pre["class"] = pre.get("class", []) + ["mkdocs-markmap"]
+            code.name = "script"
+            code["type"] = "text/template"
 
         return str(soup)