typsphinx 0.4.2__tar.gz → 0.4.3__tar.gz

{typsphinx-0.4.2 → typsphinx-0.4.3}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: typsphinx
-Version: 0.4.2
+Version: 0.4.3
 Summary: Sphinx extension for Typst output
-Author-email: Sphinx Typst Contributors <noreply@example.com>
+Author-email: YuSabo <yusabo90002@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/YuSabo90002/typsphinx
 Project-URL: Documentation, https://github.com/YuSabo90002/typsphinx#readme
 Project-URL: Repository, https://github.com/YuSabo90002/typsphinx
 Project-URL: Issues, https://github.com/YuSabo90002/typsphinx/issues
 Keywords: sphinx,typst,documentation,pdf
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Sphinx :: Extension
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -24,7 +24,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sphinx>=5.0
 Requires-Dist: docutils>=0.18
-Requires-Dist: typst>=0.11.1
+Requires-Dist: typst>=0.14.1
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
@@ -84,7 +84,7 @@ typsphinx is a Sphinx extension that enables generating Typst documents from reS
 
 ## Installation
 
-### From PyPI (Beta Release)
+### From PyPI
 
 ```bash
 pip install typsphinx

{typsphinx-0.4.2 → typsphinx-0.4.3}/README.md

@@ -39,7 +39,7 @@ typsphinx is a Sphinx extension that enables generating Typst documents from reS
 
 ## Installation
 
-### From PyPI (Beta Release)
+### From PyPI
 
 ```bash
 pip install typsphinx

{typsphinx-0.4.2 → typsphinx-0.4.3}/pyproject.toml

@@ -4,17 +4,17 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "typsphinx"
-version = "0.4.2"
+version = "0.4.3"
 description = "Sphinx extension for Typst output"
 readme = "README.md"
 requires-python = ">=3.9"
 license = "MIT"
 authors = [
-    {name = "Sphinx Typst Contributors", email = "noreply@example.com"}
+    {name = "YuSabo", email = "yusabo90002@gmail.com"}
 ]
 keywords = ["sphinx", "typst", "documentation", "pdf"]
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Framework :: Sphinx :: Extension",
     "Intended Audience :: Developers",
     "Programming Language :: Python :: 3",
@@ -29,7 +29,7 @@ classifiers = [
 dependencies = [
     "sphinx>=5.0",
     "docutils>=0.18",
-    "typst>=0.11.1",
+    "typst>=0.14.1",
 ]
 
 [project.optional-dependencies]

{typsphinx-0.4.2 → typsphinx-0.4.3}/tests/test_inline_references.py

@@ -186,3 +186,154 @@ class TestInlineReferenceConversion:
         output = translator.astext()
         # Literal should use raw() function in unified code mode
         assert 'raw("code_reference")' in output
+
+
+class TestEmptyURLHandling:
+    """Test empty URL handling in references (Typst 0.14+ compatibility)."""
+
+    def test_empty_refuri_skips_link_wrapper(self, temp_sphinx_app: SphinxTestApp):
+        """Test that empty refuri skips link() generation."""
+        ref = nodes.reference()
+        ref["refuri"] = ""  # Empty URL
+        ref += nodes.Text("broken reference")
+
+        doc = create_document()
+        para = nodes.paragraph()
+        para += ref
+        doc += para
+
+        writer = TypstWriter(temp_sphinx_app.builder)
+        writer.document = doc
+        translator = TypstTranslator(doc, temp_sphinx_app.builder)
+        doc.walkabout(translator)
+
+        output = translator.astext()
+        # Should NOT generate link()
+        assert 'link("")' not in output
+        assert 'link("", ' not in output
+        # Should render content as plain text
+        assert "broken reference" in output
+
+    def test_empty_refuri_renders_content_as_text(self, temp_sphinx_app: SphinxTestApp):
+        """Test that content is rendered as plain text when refuri is empty."""
+        ref = nodes.reference()
+        ref["refuri"] = ""
+        ref += nodes.Text("nonexistent-section")
+
+        doc = create_document()
+        para = nodes.paragraph()
+        para += ref
+        doc += para
+
+        writer = TypstWriter(temp_sphinx_app.builder)
+        writer.document = doc
+        translator = TypstTranslator(doc, temp_sphinx_app.builder)
+        doc.walkabout(translator)
+
+        output = translator.astext()
+        # Content should be present as text
+        assert "nonexistent-section" in output
+        # No link wrapper
+        assert "link(" not in output
+
+    def test_empty_refuri_emits_warning(self, temp_sphinx_app: SphinxTestApp):
+        """Test that warning is emitted for empty refuri."""
+        ref = nodes.reference()
+        ref["refuri"] = ""
+        ref += nodes.Text("broken-link")
+
+        doc = create_document()
+        para = nodes.paragraph()
+        para += ref
+        doc += para
+
+        writer = TypstWriter(temp_sphinx_app.builder)
+        writer.document = doc
+        translator = TypstTranslator(doc, temp_sphinx_app.builder)
+
+        # Capture warnings
+        import io
+        from contextlib import redirect_stderr
+
+        stderr_capture = io.StringIO()
+        with redirect_stderr(stderr_capture):
+            doc.walkabout(translator)
+
+        # Sphinx logger output goes to stderr in test context
+        # We just verify the code runs without error and produces expected output
+        output = translator.astext()
+        assert "broken-link" in output
+        assert 'link("")' not in output
+
+    def test_valid_refuri_unchanged(self, temp_sphinx_app: SphinxTestApp):
+        """Test that valid refuri generates link() as before (regression test)."""
+        ref = nodes.reference()
+        ref["refuri"] = "https://python.org"
+        ref += nodes.Text("Python")
+
+        doc = create_document()
+        para = nodes.paragraph()
+        para += ref
+        doc += para
+
+        writer = TypstWriter(temp_sphinx_app.builder)
+        writer.document = doc
+        translator = TypstTranslator(doc, temp_sphinx_app.builder)
+        doc.walkabout(translator)
+
+        output = translator.astext()
+        # Should generate link()
+        assert 'link("https://python.org"' in output
+        assert "Python" in output
+
+    def test_internal_reference_with_hash(self, temp_sphinx_app: SphinxTestApp):
+        """Test that internal references (starting with #) work correctly."""
+        ref = nodes.reference()
+        ref["refuri"] = "#section-label"
+        ref += nodes.Text("See section")
+
+        doc = create_document()
+        para = nodes.paragraph()
+        para += ref
+        doc += para
+
+        writer = TypstWriter(temp_sphinx_app.builder)
+        writer.document = doc
+        translator = TypstTranslator(doc, temp_sphinx_app.builder)
+        doc.walkabout(translator)
+
+        output = translator.astext()
+        # Should generate link(<label>, ...)
+        assert "link(<section-label>" in output
+        assert "See section" in output
+
+    def test_multiple_empty_urls(self, temp_sphinx_app: SphinxTestApp):
+        """Test that multiple empty URLs are handled correctly."""
+        # First empty reference
+        ref1 = nodes.reference()
+        ref1["refuri"] = ""
+        ref1 += nodes.Text("ref1")
+
+        # Second empty reference
+        ref2 = nodes.reference()
+        ref2["refuri"] = ""
+        ref2 += nodes.Text("ref2")
+
+        doc = create_document()
+        para = nodes.paragraph()
+        para += ref1
+        para += nodes.Text(" and ")
+        para += ref2
+        doc += para
+
+        writer = TypstWriter(temp_sphinx_app.builder)
+        writer.document = doc
+        translator = TypstTranslator(doc, temp_sphinx_app.builder)
+        doc.walkabout(translator)
+
+        output = translator.astext()
+        # Both should be rendered as text
+        assert "ref1" in output
+        assert "ref2" in output
+        # No link wrappers
+        assert 'link("")' not in output

typsphinx-0.4.3/tests/test_template_assets.py

@@ -0,0 +1,403 @@
+"""
+Tests for template asset copying functionality (Issue #75).
+
+This module tests the copy_template_assets() method and related functionality
+for automatically copying assets (fonts, images, logos) referenced by custom templates.
+"""
+
+import pytest
+from sphinx.testing.util import SphinxTestApp
+
+
+@pytest.fixture
+def temp_app_with_template(tmp_path):
+    """
+    Create a temporary Sphinx app with a custom template and assets.
+
+    Directory structure:
+        source/
+            index.rst
+            _templates/
+                template.typ
+                logo.png
+                assets/
+                    font.otf
+                    icon.svg
+    """
+    srcdir = tmp_path / "source"
+    srcdir.mkdir()
+
+    # Create index.rst
+    (srcdir / "index.rst").write_text(
+        "Test Document\n" "=============\n" "\n" "This is a test document.\n"
+    )
+
+    # Create template directory and files
+    template_dir = srcdir / "_templates"
+    template_dir.mkdir()
+
+    # Create template file
+    (template_dir / "template.typ").write_text(
+        '#import "logo.png"\n'
+        '#set text(font: "assets/font.otf")\n'
+        '#image("assets/icon.svg")\n'
+    )
+
+    # Create asset files
+    (template_dir / "logo.png").write_bytes(b"fake png data")
+
+    assets_dir = template_dir / "assets"
+    assets_dir.mkdir()
+    (assets_dir / "font.otf").write_bytes(b"fake font data")
+    (assets_dir / "icon.svg").write_text("<svg></svg>")
+
+    # Create conf.py
+    (srcdir / "conf.py").write_text(
+        "project = 'Test'\n"
+        "extensions = ['typsphinx']\n"
+        "typst_template = '_templates/template.typ'\n"
+        "typst_documents = [('index', 'index', 'Test', 'Author')]\n"
+    )
+
+    outdir = tmp_path / "build"
+
+    app = SphinxTestApp(buildername="typst", srcdir=srcdir, builddir=outdir)
+
+    return app, srcdir, outdir
+
+
+def test_copy_template_assets_automatic_directory_copy(temp_app_with_template):
+    """
+    Test automatic directory copy (default behavior).
+
+    When typst_template_assets is None, all files in the template directory
+    should be automatically copied (except .typ files).
+    """
+    app, srcdir, outdir = temp_app_with_template
+
+    # Build the project
+    app.build()
+
+    # Check that assets were copied to output directory
+    typst_outdir = outdir / "typst"
+    template_out_dir = typst_outdir / "_templates"
+
+    assert (template_out_dir / "logo.png").exists()
+    assert (template_out_dir / "assets" / "font.otf").exists()
+    assert (template_out_dir / "assets" / "icon.svg").exists()
+
+    # Verify file contents match
+    assert (template_out_dir / "logo.png").read_bytes() == b"fake png data"
+    assert (template_out_dir / "assets" / "font.otf").read_bytes() == b"fake font data"
+    assert (template_out_dir / "assets" / "icon.svg").read_text() == "<svg></svg>"
+
+
+def test_copy_template_assets_explicit_list(tmp_path):
+    """
+    Test explicit asset list specification.
+
+    When typst_template_assets is configured, only specified assets should be copied.
+    """
+    srcdir = tmp_path / "source"
+    srcdir.mkdir()
+
+    # Create index.rst
+    (srcdir / "index.rst").write_text(
+        "Test Document\n" "=============\n" "\n" "This is a test document.\n"
+    )
+
+    # Create template directory and files
+    template_dir = srcdir / "_templates"
+    template_dir.mkdir()
+
+    (template_dir / "template.typ").write_text('#image("logo.png")')
+    (template_dir / "logo.png").write_bytes(b"logo data")
+    (template_dir / "unused.png").write_bytes(b"unused data")
+
+    # Create conf.py with explicit asset list
+    (srcdir / "conf.py").write_text(
+        "project = 'Test'\n"
+        "extensions = ['typsphinx']\n"
+        "typst_template = '_templates/template.typ'\n"
+        "typst_template_assets = ['_templates/logo.png']\n"
+        "typst_documents = [('index', 'index', 'Test', 'Author')]\n"
+    )
+
+    outdir = tmp_path / "build"
+
+    app = SphinxTestApp(buildername="typst", srcdir=srcdir, builddir=outdir)
+
+    # Build the project
+    app.build()
+
+    # Check that only specified asset was copied
+    typst_outdir = outdir / "typst"
+    template_out_dir = typst_outdir / "_templates"
+
+    assert (template_out_dir / "logo.png").exists()
+    assert not (template_out_dir / "unused.png").exists()
+
+
+def test_copy_template_assets_glob_pattern(tmp_path):
+    """
+    Test glob pattern support in asset list.
+
+    Patterns like "*.png" should match multiple files.
+    """
+    srcdir = tmp_path / "source"
+    srcdir.mkdir()
+
+    # Create index.rst
+    (srcdir / "index.rst").write_text(
+        "Test Document\n" "=============\n" "\n" "This is a test document.\n"
+    )
+
+    # Create template directory and files
+    template_dir = srcdir / "_templates"
+    template_dir.mkdir()
+
+    (template_dir / "template.typ").write_text('#image("logo.png")')
+    (template_dir / "logo.png").write_bytes(b"logo data")
+    (template_dir / "icon.png").write_bytes(b"icon data")
+    (template_dir / "readme.txt").write_text("readme")
+
+    # Create conf.py with glob pattern
+    (srcdir / "conf.py").write_text(
+        "project = 'Test'\n"
+        "extensions = ['typsphinx']\n"
+        "typst_template = '_templates/template.typ'\n"
+        "typst_template_assets = ['_templates/*.png']\n"
+        "typst_documents = [('index', 'index', 'Test', 'Author')]\n"
+    )
+
+    outdir = tmp_path / "build"
+
+    app = SphinxTestApp(buildername="typst", srcdir=srcdir, builddir=outdir)
+
+    # Build the project
+    app.build()
+
+    # Check that all PNG files were copied, but not TXT
+    typst_outdir = outdir / "typst"
+    template_out_dir = typst_outdir / "_templates"
+
+    assert (template_out_dir / "logo.png").exists()
+    assert (template_out_dir / "icon.png").exists()
+    assert not (template_out_dir / "readme.txt").exists()
+
+
+def test_copy_template_assets_empty_list_disables(tmp_path):
+    """
+    Test that empty list disables automatic copying.
+
+    typst_template_assets = [] should disable all automatic asset copying.
+    """
+    srcdir = tmp_path / "source"
+    srcdir.mkdir()
+
+    # Create index.rst
+    (srcdir / "index.rst").write_text(
+        "Test Document\n" "=============\n" "\n" "This is a test document.\n"
+    )
+
+    # Create template directory and files
+    template_dir = srcdir / "_templates"
+    template_dir.mkdir()
+
+    (template_dir / "template.typ").write_text('#image("logo.png")')
+    (template_dir / "logo.png").write_bytes(b"logo data")
+
+    # Create conf.py with empty asset list
+    (srcdir / "conf.py").write_text(
+        "project = 'Test'\n"
+        "extensions = ['typsphinx']\n"
+        "typst_template = '_templates/template.typ'\n"
+        "typst_template_assets = []\n"
+        "typst_documents = [('index', 'index', 'Test', 'Author')]\n"
+    )
+
+    outdir = tmp_path / "build"
+
+    app = SphinxTestApp(buildername="typst", srcdir=srcdir, builddir=outdir)
+
+    # Build the project
+    app.build()
+
+    # Check that assets were NOT copied
+    typst_outdir = outdir / "typst"
+    template_out_dir = typst_outdir / "_templates"
+
+    # Template file should exist (copied by _write_template_file)
+    assert (typst_outdir / "_template.typ").exists()
+
+    # But logo.png should NOT be copied
+    assert not (template_out_dir / "logo.png").exists()
+
+
+def test_copy_template_assets_no_template(tmp_path):
+    """
+    Test that no assets are copied when no template is configured.
+
+    This ensures backward compatibility with projects not using templates.
+    """
+    srcdir = tmp_path / "source"
+    srcdir.mkdir()
+
+    # Create index.rst
+    (srcdir / "index.rst").write_text(
+        "Test Document\n" "=============\n" "\n" "This is a test document.\n"
+    )
+
+    # Create conf.py WITHOUT template configuration
+    (srcdir / "conf.py").write_text(
+        "project = 'Test'\n"
+        "extensions = ['typsphinx']\n"
+        "typst_documents = [('index', 'index', 'Test', 'Author')]\n"
+    )
+
+    outdir = tmp_path / "build"
+
+    app = SphinxTestApp(buildername="typst", srcdir=srcdir, builddir=outdir)
+
+    # Build should succeed without errors
+    app.build()
+
+    # No template directory should be created
+    typst_outdir = outdir / "typst"
+    template_out_dir = typst_outdir / "_templates"
+
+    assert not template_out_dir.exists()
+
+
+def test_copy_template_assets_with_typst_package(tmp_path):
+    """
+    Test that assets are NOT copied when using Typst Universe packages.
+
+    Typst Universe packages handle assets automatically, so we should skip copying.
+    """
+    srcdir = tmp_path / "source"
+    srcdir.mkdir()
+
+    # Create index.rst
+    (srcdir / "index.rst").write_text(
+        "Test Document\n" "=============\n" "\n" "This is a test document.\n"
+    )
+
+    # Create template directory (even though using package)
+    template_dir = srcdir / "_templates"
+    template_dir.mkdir()
+    (template_dir / "logo.png").write_bytes(b"logo data")
+
+    # Create conf.py with Typst package (takes precedence over template)
+    (srcdir / "conf.py").write_text(
+        "project = 'Test'\n"
+        "extensions = ['typsphinx']\n"
+        "typst_package = '@preview/charged-ieee:0.1.0'\n"
+        "typst_template = '_templates/template.typ'\n"
+        "typst_documents = [('index', 'index', 'Test', 'Author')]\n"
+    )
+
+    outdir = tmp_path / "build"
+
+    app = SphinxTestApp(buildername="typst", srcdir=srcdir, builddir=outdir)
+
+    # Build the project
+    app.build()
+
+    # Check that assets were NOT copied (package handles them)
+    typst_outdir = outdir / "typst"
+    template_out_dir = typst_outdir / "_templates"
+
+    assert not (template_out_dir / "logo.png").exists()
+
+
+def test_copy_template_assets_missing_source(tmp_path, caplog):
+    """
+    Test graceful handling of missing source files.
+
+    Should log warning but not fail the build.
+    """
+    srcdir = tmp_path / "source"
+    srcdir.mkdir()
+
+    # Create index.rst
+    (srcdir / "index.rst").write_text(
+        "Test Document\n" "=============\n" "\n" "This is a test document.\n"
+    )
+
+    # Create template directory
+    template_dir = srcdir / "_templates"
+    template_dir.mkdir()
+
+    (template_dir / "template.typ").write_text('#image("logo.png")')
+    # Note: logo.png does NOT exist
+
+    # Create conf.py with explicit asset that doesn't exist
+    (srcdir / "conf.py").write_text(
+        "project = 'Test'\n"
+        "extensions = ['typsphinx']\n"
+        "typst_template = '_templates/template.typ'\n"
+        "typst_template_assets = ['_templates/logo.png']\n"
+        "typst_documents = [('index', 'index', 'Test', 'Author')]\n"
+    )
+
+    outdir = tmp_path / "build"
+
+    app = SphinxTestApp(buildername="typst", srcdir=srcdir, builddir=outdir)
+
+    # Build should succeed despite missing file
+    app.build()
+
+    # Check that warning was logged in Sphinx's warning stream
+    warnings = app._warning.getvalue()
+    assert "Template asset not found" in warnings
+
+
+def test_copy_template_assets_typstpdf_builder(tmp_path):
+    """
+    Test that asset copying works with TypstPDFBuilder.
+
+    Assets should be copied before PDF compilation.
+    """
+    srcdir = tmp_path / "source"
+    srcdir.mkdir()
+
+    # Create index.rst
+    (srcdir / "index.rst").write_text(
+        "Test Document\n" "=============\n" "\n" "This is a test document.\n"
+    )
+
+    # Create template directory and files
+    template_dir = srcdir / "_templates"
+    template_dir.mkdir()
+
+    (template_dir / "template.typ").write_text('#image("logo.png")')
+    (template_dir / "logo.png").write_bytes(b"logo data")
+
+    # Create conf.py
+    (srcdir / "conf.py").write_text(
+        "project = 'Test'\n"
+        "extensions = ['typsphinx']\n"
+        "typst_template = '_templates/template.typ'\n"
+        "typst_documents = [('index', 'index', 'Test', 'Author')]\n"
+    )
+
+    outdir = tmp_path / "build"
+
+    app = SphinxTestApp(
+        buildername="typstpdf", srcdir=srcdir, builddir=outdir  # Use PDF builder
+    )
+
+    # Build the project
+    # Note: This may fail at PDF compilation if typst-py is not properly set up,
+    # but asset copying should still happen
+    try:
+        app.build()
+    except Exception:
+        pass  # Ignore PDF compilation errors
+
+    # Check that assets were copied before PDF compilation
+    typstpdf_outdir = outdir / "typstpdf"
+    template_out_dir = typstpdf_outdir / "_templates"
+
+    assert (template_out_dir / "logo.png").exists()

{typsphinx-0.4.2 → typsphinx-0.4.3}/typsphinx/__init__.py

@@ -11,8 +11,8 @@ sources using Sphinx, which can then be compiled to PDF using the Typst compiler
 :license: MIT, see LICENSE for details.
 """
 
-__version__ = "0.4.1"
-__author__ = "Sphinx Typst Contributors"
+__version__ = "0.4.3"
+__author__ = "YuSabo"
 
 from typing import Any, Dict
 
@@ -55,6 +55,8 @@ def setup(app: Sphinx) -> Dict[str, Any]:
     # Task 13.4: Output directory and debug mode
     app.add_config_value("typst_output_dir", "_build/typst", "html", [str])
     app.add_config_value("typst_debug", False, "html", [bool])
+    # Issue #75: Template asset support
+    app.add_config_value("typst_template_assets", None, "html", [list, type(None)])
 
     return {
         "version": __version__,

{typsphinx-0.4.2 → typsphinx-0.4.3}/typsphinx/builder.py

@@ -280,14 +280,189 @@ class TypstBuilder(Builder):
             except Exception as e:
                 logger.warning(f"Failed to copy image {imguri}: {e}")
 
+    def copy_template_assets(self) -> None:
+        """
+        Copy template-associated assets to the output directory.
+
+        When using custom Typst templates via typst_template configuration,
+        this method copies assets (fonts, images, logos, etc.) referenced by
+        the template to the output directory.
+
+        Behavior:
+        - If typst_template_assets is configured, copies only specified files/directories
+        - If typst_template_assets is None (default), automatically copies entire template directory
+        - If typst_template_assets is empty list, disables automatic copying
+        - Skips .typ files to avoid duplicating template file (already handled by _write_template_file)
+
+        This follows the same pattern as copy_image_files() from Issue #38.
+        """
+
+        # Early return if no custom template is configured
+        template_path = getattr(self.config, "typst_template", None)
+        if not template_path:
+            return  # No custom template
+
+        # Early return if using Typst Universe package (assets handled by Typst compiler)
+        typst_package = getattr(self.config, "typst_package", None)
+        if typst_package:
+            return
+
+        # Get template assets configuration
+        template_assets = getattr(self.config, "typst_template_assets", None)
+
+        # Check if explicitly disabled (empty list)
+        if template_assets is not None and len(template_assets) == 0:
+            logger.debug("Template asset copying disabled (empty list)")
+            return
+
+        logger.info("Copying template assets...")
+
+        if template_assets:
+            # Option 2: Explicit asset list
+            self._copy_explicit_assets(template_assets)
+        else:
+            # Option 1: Automatic directory copy
+            self._copy_template_directory(template_path)
+
+    def _copy_template_directory(self, template_path: str) -> None:
+        """
+        Copy entire template directory to output (default behavior).
+
+        Automatically copies all files in the template directory,
+        excluding .typ files (which are handled separately).
+
+        Args:
+            template_path: Path to template file relative to source directory
+        """
+        import os
+
+        # Get template directory path
+        template_dir = path.dirname(template_path)
+        if not template_dir:
+            # Template is in root directory, no assets to copy
+            return
+
+        # Resolve absolute paths
+        src_dir = path.join(self.srcdir, template_dir)
+        dest_dir = path.join(self.outdir, template_dir)
+
+        # Check if template directory exists
+        if not path.exists(src_dir):
+            logger.warning(f"Template directory not found: {src_dir}")
+            return
+
+        # Track copied files for logging
+        copied_count = 0
+
+        # Walk through directory and copy all files except .typ
+        for root, _dirs, files in os.walk(src_dir):
+            for file in files:
+                # Skip .typ files (already handled by _write_template_file)
+                if file.endswith(".typ"):
+                    continue
+
+                # Get source and destination paths
+                src_file = path.join(root, file)
+                rel_path = path.relpath(src_file, src_dir)
+                dest_file = path.join(dest_dir, rel_path)
+
+                # Ensure destination directory exists
+                ensuredir(path.dirname(dest_file))
+
+                # Copy the file
+                try:
+                    shutil.copy2(src_file, dest_file)
+                    logger.debug(f"Copied template asset: {rel_path}")
+                    copied_count += 1
+                except Exception as e:
+                    logger.warning(f"Failed to copy template asset {rel_path}: {e}")
+
+        if copied_count > 0:
+            logger.info(f"Copied {copied_count} template asset(s) from {template_dir}/")
+
+    def _copy_explicit_assets(self, assets: list) -> None:
+        """
+        Copy explicitly specified assets.
+
+        Supports individual files, directories, and glob patterns.
+
+        Args:
+            assets: List of asset paths (relative to source directory)
+                   May include glob patterns like "*.png" or "fonts/*.otf"
+        """
+        import glob
+
+        copied_count = 0
+
+        for asset_pattern in assets:
+            # Resolve absolute pattern path
+            abs_pattern = path.join(self.srcdir, asset_pattern)
+
+            # Check if pattern contains wildcards
+            if "*" in asset_pattern or "?" in asset_pattern:
+                # Expand glob pattern
+                matches = glob.glob(abs_pattern, recursive=True)
+                if not matches:
+                    logger.warning(f"No files matched pattern: {asset_pattern}")
+                    continue
+
+                for match in matches:
+                    if self._copy_single_asset(match, asset_pattern):
+                        copied_count += 1
+            else:
+                # Single file or directory
+                if self._copy_single_asset(abs_pattern, asset_pattern):
+                    copied_count += 1
+
+        if copied_count > 0:
+            logger.info(f"Copied {copied_count} explicitly specified template asset(s)")
+
+    def _copy_single_asset(self, src_path: str, original_pattern: str) -> bool:
+        """
+        Copy a single asset file or directory.
+
+        Args:
+            src_path: Absolute source path
+            original_pattern: Original pattern from configuration (for error messages)
+
+        Returns:
+            True if successfully copied, False otherwise
+        """
+
+        # Check if source exists
+        if not path.exists(src_path):
+            logger.warning(f"Template asset not found: {original_pattern}")
+            return False
+
+        # Calculate relative path from source directory
+        rel_path = path.relpath(src_path, self.srcdir)
+        dest_path = path.join(self.outdir, rel_path)
+
+        try:
+            if path.isdir(src_path):
+                # Copy directory recursively
+                # Use copytree with dirs_exist_ok for Python 3.8+
+                shutil.copytree(src_path, dest_path, dirs_exist_ok=True)
+                logger.debug(f"Copied template asset directory: {rel_path}/")
+            else:
+                # Copy single file
+                ensuredir(path.dirname(dest_path))
+                shutil.copy2(src_path, dest_path)
+                logger.debug(f"Copied template asset: {rel_path}")
+            return True
+        except Exception as e:
+            logger.warning(f"Failed to copy template asset {rel_path}: {e}")
+            return False
+
     def finish(self) -> None:
         """
         Finish the build process.
 
         This method is called once after all documents have been written.
-        Copies image files to the output directory.
+        Copies image files and template assets to the output directory.
         """
         self.copy_image_files()
+        self.copy_template_assets()
 
 
 class TypstPDFBuilder(TypstBuilder):

{typsphinx-0.4.2 → typsphinx-0.4.3}/typsphinx/translator.py

@@ -1930,6 +1930,19 @@ class TypstTranslator(SphinxTranslator):
         # Get the reference URI
         refuri = node.get("refuri", "")
 
+        # Handle empty URLs (Typst 0.14+ rejects empty URLs)
+        # This can occur with unresolved references, broken cross-references,
+        # or malformed reStructuredText. Instead of generating invalid link("", ...),
+        # we skip the link wrapper and render content as plain text.
+        if not refuri:
+            logger.warning(
+                f"Reference node has empty URL. "
+                f"Link will be rendered as plain text. "
+                f"Check for broken references in source: {node.astext()}"
+            )
+            self._skip_link_wrapper = True
+            return
+
         # Determine if we need # prefix (in markup mode)
         prefix = "#" if self._in_markup_mode else ""
 
@@ -1961,6 +1974,16 @@ class TypstTranslator(SphinxTranslator):
         Args:
             node: The reference node
         """
+        # Skip link wrapper closing if we skipped it in visit
+        if getattr(self, "_skip_link_wrapper", False):
+            self._skip_link_wrapper = False
+            # Restore list item separator state if needed
+            if hasattr(self, "_reference_was_list_item_needs_separator"):
+                if self.in_list_item:
+                    self.list_item_needs_separator = True
+                delattr(self, "_reference_was_list_item_needs_separator")
+            return
+
         # Close the link function
         self.add_text(")")
 

{typsphinx-0.4.2 → typsphinx-0.4.3}/typsphinx.egg-info/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: typsphinx
-Version: 0.4.2
+Version: 0.4.3
 Summary: Sphinx extension for Typst output
-Author-email: Sphinx Typst Contributors <noreply@example.com>
+Author-email: YuSabo <yusabo90002@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/YuSabo90002/typsphinx
 Project-URL: Documentation, https://github.com/YuSabo90002/typsphinx#readme
 Project-URL: Repository, https://github.com/YuSabo90002/typsphinx
 Project-URL: Issues, https://github.com/YuSabo90002/typsphinx/issues
 Keywords: sphinx,typst,documentation,pdf
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Sphinx :: Extension
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -24,7 +24,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: sphinx>=5.0
 Requires-Dist: docutils>=0.18
-Requires-Dist: typst>=0.11.1
+Requires-Dist: typst>=0.14.1
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
@@ -84,7 +84,7 @@ typsphinx is a Sphinx extension that enables generating Typst documents from reS
 
 ## Installation
 
-### From PyPI (Beta Release)
+### From PyPI
 
 ```bash
 pip install typsphinx

{typsphinx-0.4.2 → typsphinx-0.4.3}/typsphinx.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ tests/test_math_mitex.py
 tests/test_math_native.py
 tests/test_nested_toctree_paths.py
 tests/test_pdf_generation.py
+tests/test_template_assets.py
 tests/test_template_codly.py
 tests/test_template_engine.py
 tests/test_template_mitex.py

{typsphinx-0.4.2 → typsphinx-0.4.3}/typsphinx.egg-info/requires.txt

@@ -1,6 +1,6 @@
 sphinx>=5.0
 docutils>=0.18
-typst>=0.11.1
+typst>=0.14.1
 
 [dev]
 pytest>=7.0