Demo Page - Zensical Features Showcase¶

This page demonstrates the powerful authoring capabilities available in Zensical, a modern static site generator. You'll find examples of rich formatting, interactive elements, and technical documentation features.

hide:
  - toc

Links and References¶

Basic Links¶

You can create internal links to other pages or external links to websites.

Links with Tooltips¶

Zensical supports hoverable tooltips using the title attribute.

You can also use abbreviations for inline tooltips. Hover over the abbreviation below:

The API endpoint processes requests through multiple stages.

Links with preview¶

Check out our API.

Reference-style Links¶

Check out our data API and metadata system.

Page Status Indicators¶

The status indicator at the top of this page is set via front matter: status: new

Available status options:

• new - Recently added content
• deprecated - Outdated or superseded content

Admonitions (Callouts)¶

Standard Types¶

Collapsible Admonitions¶

Inline Admonitions¶

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla et euismod nulla. Curabitur feugiat, tortor non consequat finibus, justo purus auctor massa, nec semper lorem quam in massa. This text wraps around the inline admonition.

Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vestibulum tortor quam, feugiat vitae, ultricies eget, tempor sit amet, ante.

Buttons¶

You can create styled buttons for calls to action:

Getting Started View on GitHub API Documentation

Code Blocks¶

Basic Syntax Highlighting¶

def process_data(data: list) -> list:
    """Process and clean the input data."""
    # Remove duplicates
    data = list(set(data))

    # Filter invalid values
    data = [x for x in data if x > 0]

    return sorted(data)

With Title and Line Numbers¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from typing import Dict, Any
import json

def load_config(config_path: str) -> Dict[str, Any]:
    """Load configuration from JSON file."""
    with open(config_path, 'r') as f:
        return json.load(f)

def process_records(records: list, config: Dict[str, Any]) -> list:
    """Process records according to configuration."""
    # Filter records
    filtered = [r for r in records if r.get('active', True)]

    # Transform according to config
    transformed = [transform_record(r, config) for r in filtered]

    return transformed

With Highlighted Lines¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import json
from pathlib import Path
from datetime import datetime

# Load data file
data_path = Path("data/records.json")
with open(data_path, 'r') as f:
    records = json.load(f)

# Process records
processed = [process(r) for r in records]

With Annotations¶

def validate_config(config: dict) -> bool:
    """Validate configuration structure."""
    required_keys = {'name', 'version', 'settings'}  # (1)!

    if not all(key in config for key in required_keys):  # (2)!
        return False

    return True

1. Define the required configuration keys that must be present.
2. Check that all required keys exist in the configuration dictionary.

Multiple Languages¶

def calculate_growth_rate(current, previous):
    """Calculate percentage growth rate."""
    return ((current - previous) / previous) * 100

SELECT
    country,
    year,
    ((value - LAG(value) OVER (ORDER BY year)) / LAG(value) OVER (ORDER BY year)) * 100 AS growth_rate
FROM
    indicators
WHERE
    indicator_name = 'GDP'
ORDER BY
    country, year;

# Build documentation
make docs.build

# Serve locally
make docs.serve

Mermaid Diagrams¶

Flow Chart¶

graph LR
    A[Input] -->|Raw Data| B[Processing]
    B -->|Cleaned| C[Transform]
    C -->|Validated| D[Storage]
    D -->|Published| E[Output]

    style A fill:#f9f,stroke:#333
    style E fill:#9f9,stroke:#333

Sequence Diagram¶

sequenceDiagram
    participant User
    participant App
    participant Database
    participant API

    User->>App: Request data update
    App->>Database: Check current version
    Database-->>App: Version info
    App->>App: Process new data
    App->>Database: Store updated data
    Database-->>App: Success
    App->>API: Refresh cache
    API-->>User: Updated data available

System Architecture¶

graph TB
    subgraph "Data Sources"
        S1[API Source]
        S2[File Upload]
        S3[Database]
    end

    subgraph "Processing Pipeline"
        Ingest[Data Ingestion]
        Valid[Validation]
        Trans[Transformation]
        Store[Storage]
    end

    subgraph "Output Layer"
        DB[(Database)]
        API[REST API]
        UI[Web Interface]
    end

    S1 --> Ingest
    S2 --> Ingest
    S3 --> Ingest
    Ingest --> Valid
    Valid --> Trans
    Trans --> Store
    Store --> DB
    DB --> API
    DB --> UI

Tabs¶

Content Tabs¶

Tables¶

Simple Table¶

Advanced Table with Alignment¶

Table with Links¶

Grids¶

Footnotes¶

The ETL pipeline¹ processes data from multiple international organizations² and makes it available through our API³.

Mathematical Notation¶

Inline Math¶

The growth rate can be calculated as \(r = \frac{P_t - P_{t-1}}{P_{t-1}} \times 100\), where \(P_t\) is the current population.

Block Math¶

The GDP per capita growth rate:

Images¶

Basic Image¶

Image with Caption¶

Image Grid¶

Keyboard Keys¶

Use Ctrl+Shift+R to hard refresh your browser and clear the favicon cache.

Common ETL commands:

• Run a step: Ctrl+Enter
• Stop execution: Ctrl+C
• Search documentation: Ctrl+K or Cmd+K

Progress Bars¶

Track your ETL learning progress:

75% Complete

Dataset processing status:

Snapshot ✓

Meadow ✓

Garden

Grapher

Icons¶

Zensical includes thousands of icons from multiple icon sets. Some examples:

• Database operations
• Data visualization
• Code development
• Python programming
• Version control
• Git branching
• MySQL database

Horizontal Rules¶

Use horizontal rules to separate major sections:

Summary¶

This demo page showcases the rich authoring capabilities available in Zensical:

✓ Interactive elements (buttons, tabs, collapsible sections) ✓ Rich formatting (admonitions, grids, cards) ✓ Technical content (code blocks, diagrams, math) ✓ Documentation features (tooltips, footnotes, cross-references) ✓ Visual elements (images, icons, progress bars)