edwh-editorjs 2.0.0b1__tar.gz → 2.0.0b3__tar.gz

{edwh_editorjs-2.0.0b1 → edwh_editorjs-2.0.0b3}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 <!--next-version-placeholder-->
 
+## v2.0.0-beta.3 (2024-11-06)
+
+### Fix
+
+* Various fixes with nested lists ([`52a7773`](https://github.com/educationwarehouse/edwh-editorjs/commit/52a7773470dce3eee6a2d17d46b594551ed043a5))
+
+## v2.0.0-beta.2 (2024-11-06)
+
+### Feature
+
+* Work in progress to do a rebuild based on mdast ([`28c12f1`](https://github.com/educationwarehouse/edwh-editorjs/commit/28c12f1f74c71a995f9f8097f1b26be45f835ad4))
+
 ## v2.0.0-beta.1 (2024-11-06)
 
 

{edwh_editorjs-2.0.0b1 → edwh_editorjs-2.0.0b3}/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
 Copyright (c) 2021 SKevo
+Copyright (c) 2024 Education Warehouse
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

edwh_editorjs-2.0.0b3/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.3
+Name: edwh-editorjs
+Version: 2.0.0b3
+Summary: EditorJS.py
+Project-URL: Homepage, https://github.com/educationwarehouse/edwh-EditorJS
+Author-email: SKevo <skevo.cw@gmail.com>, Robin van der Noord <robin.vdn@educationwarehouse.nl>
+License: MIT
+License-File: LICENSE
+Keywords: bleach,clean,editor,editor.js,html,javascript,json,parser,wysiwyg
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: markdown2
+Requires-Dist: mdast
+Provides-Extra: dev
+Requires-Dist: edwh; extra == 'dev'
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: su6[all]; extra == 'dev'
+Requires-Dist: types-bleach; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# edwh-editorjs
+

edwh_editorjs-2.0.0b3/README.md

@@ -0,0 +1,2 @@
+# edwh-editorjs
+

edwh_editorjs-2.0.0b3/editorjs/__about__.py

@@ -0,0 +1 @@
+__version__ = "2.0.0-beta.3"

edwh_editorjs-2.0.0b3/editorjs/__init__.py

@@ -0,0 +1,5 @@
+from .core import EditorJS
+
+__all__ = [
+    "EditorJS",
+]

edwh_editorjs-2.0.0b3/editorjs/blocks.py

@@ -0,0 +1,382 @@
+"""
+mdast to editorjs
+"""
+
+import abc
+import re
+import typing as t
+
+from .exceptions import TODO
+from .types import EditorChildData, MDChildNode
+
+
+class EditorJSBlock(abc.ABC):
+    @classmethod
+    @abc.abstractmethod
+    def to_markdown(cls, data: EditorChildData) -> str: ...
+
+    @classmethod
+    @abc.abstractmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]: ...
+
+    @classmethod
+    @abc.abstractmethod
+    def to_text(cls, node: MDChildNode) -> str: ...
+
+
+BLOCKS: dict[str, EditorJSBlock] = {}
+
+
+def block(*names: str):
+    def wrapper(cls):
+        for name in names:
+            BLOCKS[name] = cls
+        return cls
+
+    return wrapper
+
+
+def process_styled_content(item: MDChildNode, strict: bool = True) -> str:
+    """
+    Processes styled content (e.g., bold, italic) within a list item.
+
+    Args:
+        item: A ChildNode dictionary representing an inline element or text.
+        strict: Raise if 'type' is not one defined in 'html_wrappers'
+
+    Returns:
+        A formatted HTML string based on the item type.
+    """
+    _type = item.get("type")
+    html_wrappers = {
+        "text": "{value}",
+        "html": "{value}",
+        "emphasis": "<i>{value}</i>",
+        "strong": "<b>{value}</b>",
+        "strongEmphasis": "<b><i>{value}</i></b>",
+        "link": '<a href="{url}">{value}</a>',
+        "inlineCode": '<code class="inline-code">{value}</code>',
+        # todo: <mark>
+    }
+
+    if _type in BLOCKS:
+        return BLOCKS[_type].to_text(item)
+
+    if strict and _type not in html_wrappers:
+        raise ValueError(f"Unsupported type {_type} in paragraph")
+
+    # Process children recursively if they exist, otherwise use the direct value
+    if children := item.get("children"):
+        value = "".join(process_styled_content(child) for child in children)
+    else:
+        value = item.get("value", "")
+
+    template = html_wrappers.get(_type, "{value}")
+    return template.format(
+        value=value, url=item.get("url", ""), caption=item.get("caption", "")
+    )
+
+
+def default_to_text(node: MDChildNode):
+    return "".join(
+        process_styled_content(child) for child in node.get("children", [])
+    ) or process_styled_content(node)
+
+
+@block("heading", "header")
+class HeadingBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        level = data.get("level", 1)
+        text = data.get("text", "")
+
+        if not (1 <= level <= 6):
+            raise ValueError("Header level must be between 1 and 6.")
+
+        return f"{'#' * level} {text}\n"
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        """
+        Converts a Markdown header block into structured block data.
+
+        Args:
+            node: A RootNode dictionary with 'depth' and 'children'.
+
+        Returns:
+            A ChildNode dictionary representing the header data, or None if no children exist.
+
+        Raises:
+            ValueError: If an unsupported heading depth is provided.
+        """
+
+        depth = node.get("depth")
+
+        if depth is None or not (1 <= depth <= 6):
+            raise ValueError("Heading depth must be between 1 and 6.")
+
+        return [{"data": {"level": depth, "text": cls.to_text(node)}, "type": "header"}]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        children = node.get("children", [])
+        if children is None or not len(children) == 1:
+            raise ValueError("Header block must have exactly one child element")
+        child = children[0]
+        return child.get("value", "")
+
+
+@block("paragraph")
+class ParagraphBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        text = data.get("text", "")
+        return f"{text}\n"
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        result = []
+        current_text = ""
+
+        for child in node.get("children"):
+            _type = child.get("type")
+            if _type == "image":
+                if current_text:
+                    result.append({"data": {"text": current_text}, "type": "paragraph"})
+                    current_text = ""
+
+                result.extend(ImageBlock.to_json(child))
+            else:
+                current_text += cls.to_text(child)
+
+        # final text after image:
+        if current_text:
+            result.append({"data": {"text": current_text}, "type": "paragraph"})
+
+        return result
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return default_to_text(node)
+
+
+@block("list")
+class ListBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        style = data.get("style", "unordered")
+        items = data.get("items", [])
+
+        def parse_items(subitems: list[dict[str, t.Any]], depth: int = 0) -> str:
+            markdown_items = []
+            for index, item in enumerate(subitems):
+                prefix = f"{index + 1}." if style == "ordered" else "-"
+                line = f"{'\t' * depth}{prefix} {item['content']}"
+                markdown_items.append(line)
+
+                # Recurse if there are nested items
+                if item.get("items"):
+                    markdown_items.append(parse_items(item["items"], depth + 1))
+
+            return "\n".join(markdown_items)
+
+        return "\n" + parse_items(items) + "\n"
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        """
+        Converts a Markdown list block with nested items and styling into structured block data.
+
+        Args:
+            node: A RootNode dictionary with 'ordered' and 'children'.
+
+        Returns:
+            A dictionary representing the structured list data with 'items' and 'style'.
+        """
+        items = []
+        # checklists are not supported (well) by mdast
+        # so we detect it ourselves:
+        could_be_checklist = True
+
+        def is_checklist(value: str) -> bool:
+            return value.strip().startswith(("[ ]", "[x]"))
+
+        for child in node["children"]:
+            content = ""
+            subitems = []
+            # child can have content and/or items
+            for grandchild in child["children"]:
+                _type = grandchild.get("type", "")
+                if _type == "paragraph":
+                    subcontent = ParagraphBlock.to_text(grandchild)
+                    could_be_checklist = could_be_checklist and is_checklist(subcontent)
+                    content += "" + subcontent
+                elif _type == "list":
+                    could_be_checklist = False
+                    subitems.extend(ListBlock.to_json(grandchild)[0]["data"]["items"])
+                else:
+                    raise ValueError(f"Unsupported type {_type} in list")
+
+            items.append(
+                {
+                    "content": content,
+                    "items": subitems,
+                }
+            )
+
+        # todo: detect 'checklist':
+        """
+        type: checklist
+        data: {items: [{text: "a", checked: false}, {text: "b", checked: false}, {text: "c", checked: true},…]}
+        """
+
+        if could_be_checklist:
+            return [
+                {
+                    "type": "checklist",
+                    "data": {
+                        "items": [
+                            {
+                                "text": x["content"]
+                                .removeprefix("[ ] ")
+                                .removeprefix("[x] "),
+                                "checked": x["content"].startswith("[x]"),
+                            }
+                            for x in items
+                        ]
+                    },
+                }
+            ]
+        else:
+            return [
+                {
+                    "data": {
+                        "items": items,
+                        "style": "ordered" if node.get("ordered") else "unordered",
+                    },
+                    "type": "list",
+                }
+            ]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return ""
+
+
+@block("checklist")
+class ChecklistBlock(ListBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        markdown_items = []
+
+        for item in data.get("items", []):
+            text = item.get("text", "").strip()
+            char = "x" if item.get("checked", False) else " "
+            markdown_items.append(f"- [{char}] {text}")
+
+        return "\n" + "\n".join(markdown_items) + "\n"
+
+
+@block("thematicBreak", "delimiter")
+class DelimiterBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        return "***\n"
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        return [
+            {
+                "type": "delimiter",
+                "data": {},
+            }
+        ]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return ""
+
+
+@block("code")
+class CodeBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        code = data.get("code", "")
+        return f"```\n" f"{code}" f"\n```\n"
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        return [
+            {
+                "data": {"code": cls.to_text(node)},
+                "type": "code",
+            }
+        ]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return node.get("value", "")
+
+
+@block("image")
+class ImageBlock(EditorJSBlock):
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        url = data.get("url", "") or data.get("file", {}).get("url", "")
+        caption = data.get("caption", "")
+        return f"""![{caption}]({url} "{caption}")\n"""
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        return [
+            {
+                "type": "image",
+                "data": {
+                    "caption": cls.to_text(node),
+                    "file": {"url": node.get("url")},
+                },
+            }
+        ]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return node.get("alt") or node.get("caption") or ""
+
+
+@block("blockquote", "quote")
+class QuoteBlock(EditorJSBlock):
+    re_cite = re.compile(r"<cite>(.+?)<\/cite>")
+
+    @classmethod
+    def to_markdown(cls, data: EditorChildData) -> str:
+        text = data.get("text", "")
+        result = f"> {text}\n"
+        if caption := data.get("caption", ""):
+            result += f"> <cite>{caption}</cite>\n"
+        return result
+
+    @classmethod
+    def to_json(cls, node: MDChildNode) -> list[dict]:
+        caption = ""
+        text = cls.to_text(node).replace("\n", "<br/>\n")
+
+        if cite := re.search(cls.re_cite, text):
+            # Capture the value of the first group
+            caption = cite.group(1)
+            # Remove the <cite>...</cite> tags from the text
+            text = re.sub(cls.re_cite, "", text)
+
+        return [
+            {
+                "data": {
+                    "alignment": "left",
+                    "caption": caption,
+                    "text": text,
+                },
+                "type": "quote",
+            }
+        ]
+
+    @classmethod
+    def to_text(cls, node: MDChildNode) -> str:
+        return default_to_text(node)

edwh_editorjs-2.0.0b3/editorjs/core.py

@@ -0,0 +1,116 @@
+import json
+import textwrap
+import typing as t
+
+import markdown2
+import mdast
+from typing_extensions import Self
+
+from .blocks import BLOCKS
+from .exceptions import TODO
+from .helpers import unix_timestamp
+from .types import MDRootNode
+
+EDITORJS_VERSION = "2.30.6"
+
+
+class EditorJS:
+    # internal representation is mdast, because we can convert to other types
+    _mdast: MDRootNode
+
+    def __init__(self, _mdast: str | dict, extras: list = ("task_list", "fenced-code-blocks")):
+        if not isinstance(_mdast, str | dict):
+            raise TypeError("Only `str` or `dict` is supported!")
+
+        self._mdast = t.cast(
+            MDRootNode, json.loads(_mdast) if isinstance(_mdast, str) else _mdast
+        )
+
+        self._md = markdown2.Markdown(extras=extras)  # todo: striketrough, table, ?
+
+    @classmethod
+    def from_json(cls, data: str | dict) -> Self:
+        """
+        Load from EditorJS JSON Blocks
+        """
+        data = data if isinstance(data, dict) else json.loads(data)
+        markdown_items = []
+        for child in data["blocks"]:
+            _type = child["type"]
+            if not (block := BLOCKS.get(_type)):
+                raise TypeError(f"Unsupported block type `{_type}`")
+
+            markdown_items.append(block.to_markdown(child.get("data", {})))
+
+        markdown = "".join(markdown_items)
+        return cls.from_markdown(markdown)
+
+    @classmethod
+    def from_markdown(cls, data: str) -> Self:
+        """
+        Load from markdown string
+        """
+
+        return cls(mdast.md_to_json(data))
+
+    @classmethod
+    def from_mdast(cls, data: str | dict) -> Self:
+        """
+        Existing mdast representation
+        """
+        return cls(data)
+
+    def to_json(self) -> str:
+        """
+        Export EditorJS JSON Blocks
+        """
+        # logic based on https://github.com/carrara88/editorjs-md-parser/blob/main/src/MarkdownImporter.js
+        blocks = []
+        for child in self._mdast["children"]:
+            _type = child["type"]
+            if not (block := BLOCKS.get(_type)):
+                raise TypeError(f"Unsupported block type `{_type}`")
+
+            blocks.extend(block.to_json(child))
+
+        data = {"time": unix_timestamp(), "blocks": blocks, "version": EDITORJS_VERSION}
+
+        return json.dumps(data)
+
+    def to_markdown(self) -> str:
+        """
+        Export Markdown string
+        """
+        md = mdast.json_to_md(self.to_mdast())
+        # idk why this happens:
+        md = md.replace(r"\[ ]", "[ ]")
+        md = md.replace(r"\[x]", "[x]")
+        return md
+
+    def to_mdast(self) -> str:
+        """
+        Export mdast representation
+        """
+        return json.dumps(self._mdast)
+
+    def to_html(self) -> str:
+        """
+        Export HTML string
+        """
+        md = self.to_markdown()
+        return self._md.convert(md)
+
+    def __repr__(self):
+        md = self.to_markdown()
+        md = md.replace("\n", "\\n")
+        return f"EditorJS({md})"
+
+    def __str__(self):
+        return self.to_markdown()
+
+    # def __eq__(self, other: Self) -> bool:
+    #     a = self.to_markdown()
+    #     b = other.to_markdown()
+    #
+    #     remove = string.punctuation + string.whitespace
+    #     return a.translate(remove) == b.translate(remove)

edwh_editorjs-2.0.0b3/editorjs/exceptions.py

@@ -0,0 +1,3 @@
+class TODO(NotImplementedError):
+    def __init__(self, msg: str = "todo"):
+        super().__init__(msg)

edwh_editorjs-2.0.0b3/editorjs/helpers.py

@@ -0,0 +1,5 @@
+import time
+
+
+def unix_timestamp():
+    return round(time.time() * 1000)

edwh_editorjs-2.0.0b3/editorjs/types.py

@@ -0,0 +1,43 @@
+import typing as t
+
+
+class MDPosition(t.TypedDict):
+    line: int
+    column: int
+    offset: int
+
+
+class MDPositionRange(t.TypedDict):
+    start: MDPosition
+    end: MDPosition
+
+
+class MDChildNode(t.TypedDict, total=False):
+    type: str  # General identifier for node types
+    children: list["MDChildNode"]  # Recursive children of any node type
+    position: MDPositionRange
+    value: str  # Optional, for nodes like text that hold a value
+    depth: int  # Optional, for nodes like headings that have a depth
+    url: t.NotRequired[str]
+
+
+class MDRootNode(t.TypedDict):
+    type: t.Literal["root"]  # Constrains to 'root' for the root node
+    children: list[MDChildNode]  # Allows any ChildNode type in children
+    position: MDPositionRange
+
+
+class EditorChildData(t.TypedDict, total=False):
+    text: str
+    items: list["EditorChildNode"]
+
+
+class EditorChildNode(t.TypedDict):
+    type: str
+    data: EditorChildData
+
+
+class EditorRootNode(t.TypedDict):
+    time: int
+    blocks: list[EditorChildNode]
+    version: str

{edwh_editorjs-2.0.0b1 → edwh_editorjs-2.0.0b3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 name = "edwh-editorjs"
 dynamic = ["version"]
 
-description = "pyEditorJS"
+description = "EditorJS.py"
 readme = "README.md"
 authors = [
     { name = "SKevo", email = "skevo.cw@gmail.com" },
@@ -26,7 +26,9 @@ classifiers = [
 requires-python = ">=3.10"
 
 dependencies = [
-    "bleach"
+    # "bleach",
+    "mdast",
+    "markdown2",
 ]
 
 [project.optional-dependencies]
@@ -42,23 +44,23 @@ Homepage = "https://github.com/educationwarehouse/edwh-EditorJS"
 
 [tool.semantic_release]
 branch = "master"
-version_variable = "pyeditorjs/__about__.py:__version__"
+version_variable = "editorjs/__about__.py:__version__"
 change_log = "CHANGELOG.md"
 upload_to_repository = false
 upload_to_release = false
 build_command = "hatch build"
 
 [tool.hatch.version]
-path = "pyeditorjs/__about__.py"
+path = "editorjs/__about__.py"
 
 [tool.hatch.build.targets.wheel]
-packages = ["pyeditorjs"]
+packages = ["editorjs"]
 
 
 [tool.setuptools.packages.find]
-include = ["pyeditorjs"]
+include = ["editorjs"]
 exclude = ["tests"]
 
 [tool.su6]
-directory = "pyeditorjs"
+directory = "editorjs"
 stop-after-first-failure = true