Vlastní šablony a moduly

Proč tvořit vlastní šablony a moduly v CMS

Vlastní šablony a moduly umožňují přizpůsobit CMS (WordPress, Drupal, Joomla) specifickým potřebám bez kompromisů v použitelnosti, výkonu a bezpečnosti. Správné uchopení znamená držet se architektonických principů platformy (hooky, eventy, template hierarchy), zachovat možnost update jádra a rozšíření a současně budovat opakovatelně použitelné komponenty.

Architektonické rozdíly mezi WordPress, Drupal a Joomla

Principy pro tvorbu šablon napříč platformami

• Oddělte logiku od prezentace: minimum PHP v šablonách; ve WordPress využívejte krátké helpery, v Drupalu předávejte data přes preprocess, v Joomle pracujte s layout overrides.
• Komponentové myšlení: vytvářejte znovupoužitelné partialy (např. content-card, media, pagination).
• Bezpečnost: důsledné escapování výstupů (esc_html(), {{ variable|escape }}, JHtml::_()), nonce/CSRF tokeny pro formuláře.
• Přístupnost (a11y): semantické HTML, role atributy, kontrast, focus stavy, čitelné řazení DOM.
• Performance: kritické CSS v hlavičce, lazy loading médií, správná práce s keší a assety.

WordPress: tvorba šablony a child theme

1. Struktura: minimálně style.css (hlavička s metadaty), index.php, volitelně functions.php, theme.json pro nastavení editoru bloků.
2. Template hierarchy: specifické soubory pro typy obsahu (single-{post_type}.php), taxonomie (taxonomy-{taxonomy}.php), stránkování (archive.php), 404 atd.
3. Child theme: použijte pro úpravy třetí strany. V style.css nastavte Template: na rodičovský motiv; v functions.php korektně enqueue style parentu.
4. Blokový editor (Gutenberg): definujte barevné palety, spacing a typografii v theme.json; vlastní bloky publikujte jako plugin (oddělení od šablony).
5. Hooks: filtry a akce (např. pre_get_posts, the_content) pro úpravu chování bez zásahů do jádra.

WordPress: tvorba pluginu (modulu)

• Bootstrap: soubor s hlavičkou pluginu, registrace autoloaderu (PSR-4), register_activation_hook(), register_deactivation_hook().
• CPT a Taxonomy: registrujte přes register_post_type() a register_taxonomy(); dbejte na REST schema pro API.
• Bezpečnost: nonce ve formulářích (wp_verify_nonce), schopnosti (current_user_can), escapování výstupů.
• Internationalizace: __(), _e(), text domain a .pot soubory.
• Nastavení: Settings API, vlastní stránky v administraci, sanitizace vstupů.

Drupal: tvorba tématu (theme)

1. Manifest: soubor THEME_NAME.info.yml s knihovnami, regiony a závislostmi; assety deklarujte v .libraries.yml.
2. Šablony: .html.twig soubory (např. node.html.twig, page.html.twig) s Twig filtry a bezpečným escapováním.
3. Preprocess: v .theme souboru přidejte preprocess hooky (hook_preprocess_node()) pro přípravu proměnných do šablon.
4. Regiony a bloky: definujte regiony v tématu; umisťujte bloky přes UI nebo config sync.
5. Subtheme: dědičnost nad base theme (např. Stable, Classy) pro rychlý start.

Drupal: tvorba modulu

• Struktura: MODULE_NAME.info.yml, MODULE_NAME.routing.yml, MODULE_NAME.permissions.yml, kontrolery v src/Controller, služby v MODULE_NAME.services.yml.
• Hooky & eventy: implementace hook_form_alter(), hook_entity_view(), event subscriber pro Symfony eventy.
• Entity a pole: definujte vlastní entity nebo rozšiřte existující; respektujte cache metadata (#cache kontexty, tagy, max-age).
• Bezpečnost: Access Control Handlers, kontrola oprávnění v routách (_permission), CSRF tokeny ve formulářích.
• Konfigurace: Configuration API, config schema pro validaci a export/import.

Joomla: tvorba šablony a override

1. Struktura: adresář templates/THEME/ s index.php, templateDetails.xml, css/js, jazykové soubory.
2. Layout override: kopírujte view soubory rozšíření do templates/THEME/html/com_component/view/ a upravujte bez zásahu do rozšíření.
3. Modulové pozice: definujte v templateDetails.xml a používejte v layoutu; mapujte na modulární obsah.
4. JLayout: vytvářejte znovupoužitelné layouty v layouts/ a vkládejte JLayoutHelper::render().
5. Joomla 4/5: využijte moderní Web Asset Manager pro registraci a závislosti JS/CSS.

Joomla: vlastní modul/komponenta

• Modul: jednoduchý výstup s mod_modulename.php, helper třídou a layoutem; konfigurace v mod_modulename.xml.
• Komponenta (MVC): modely, view a controllery; routování přes router.php, ACL přes access.xml.
• Plugin: reakce na systémové události (např. onContentPrepare), konfigurace v XML, priorita zásahů.

Styly, design systém a práci s assety

• Design tokens: barvy, typografie, spacing a stavy komponent definujte centrálně (JSON/YAML) a generujte do CSS proměnných.
• Build pipeline: Vite/webpack pro bundling, autoprefixer, moderní moduly; ve WordPress respektujte wp_enqueue_*(), v Drupalu libraries.yml, v Joomle Web Asset Manager.
• Critical CSS a defer pro nepotřebné skripty; lazy loading obrázků a iframů.

Mezijazyková podpora (i18n) a lokalizace

• WordPress: funkce __(), _x(), text domain, generujte .pot a distribuujte .po/.mo.
• Drupal: t() a překlady konfiguračních entit; Translation UI / Locale.
• Joomla: jazykové INI soubory v language/, Text::_() v kódu.

Bezpečnostní zásady pro šablony a moduly

• Escapování: ve WordPress esc_html(), esc_attr(), v Drupalu Twig escapuje defaultně, v Joomle htmlspecialchars a helpery.
• Nonce/CSRF: wp_nonce_field(), v Drupalu form API tokeny, v Joomle JSession::checkToken().
• Validace vstupů: sanitizace, typové kontroly, filtry; žádné přímé SQL (používejte ORM/DB API).
• Oprávnění: WordPress capabilities, Drupal permissions/roles, Joomla ACL – kontrolujte před vykonáním akce.

Výkon a cache

• Fragment cache: kešujte části šablon (WordPress transients, Drupal #cache metadata, Joomla cache pluginy).
• Stránková cache: reverzní proxy (Varnish/Nginx), CDN; respektujte variace dle jazyka, role a cookies.
• Databázová efektivita: omezte dotazy, načítejte data v dávkách, přidejte indexy pro custom tabulky.

API a integrace

• WordPress REST: registrujte vlastní endpointy (register_rest_route), kontrolujte permission callback.
• Drupal JSON:API: standardní poskytování entit; případné custom controllery s access policies.
• Joomla: od verze 4 REST API jádra, rozšiřte vlastními routami a ověřením.

Testování, kvalita a CI/CD

• Statická analýza: PHPStan/Psalm, ESLint/Stylelint, PHPCS s WordPress/Drupal/Joomla standardy.
• Jednotkové a integrační testy: PHPUnit, v Drupalu Kernel/Functional tests, ve WordPress WP-CLI test suite.
• Vizualní regrese: nástroje typu BackstopJS pro porovnání renderu komponent.
• CI/CD: build, linters, testy, balení do ZIP a nasazení; verzování šablon a modulů.

Distribuce a balení

• WordPress: šablony jako theme ZIP (bez vendor bloatu), pluginy s readme.txt a assets pro repozitáře.
• Drupal: moduly/themes s korektními .info.yml, .libraries.yml, composer.json; respektujte config schemas.
• Joomla: instalační balíčky se souborem manifest.xml; udržujte backward kompatibilitu layoutů.

UX a přístupnost ve vlastních šablonách

• Semantika: používejte nadpisovou hierarchii, aria-* atributy, labely a sr-only texty pro čtečky.
• Klávesová navigace: focus trap v modálních oknech, viditelný focus, skip odkazy.
• Barvy a kontrast: dodržte WCAG 2.1 AA; definujte systémové odstíny pro různé stavy (hover/active/error).

Migrace a kompatibilita

• WordPress: kompatibilita s blokovým editorem vs. classic; připravte fallback styly a theme-support deklarace.
• Drupal: směrování hooků mezi verzemi, upgrade path pro konfigurace, deprecated API náhrady.
• Joomla: přechod 3 → 4/5 (Web Asset Manager, Namespaces), kontrola starých plugin eventů.

Licencování a právní aspekty

• Open-source licence: respektujte GPL (WordPress/Joomla), kompatibilitu závislostí.
• Třetí strany: ověřte práva k fontům, ikonám, obrázkům; přiložte licence do balíčku.
• GDPR: minimalizace osobních údajů v šablonách a modulech, cookie banner jen když je skutečně třeba.

Kontrolní seznam před uvedením do provozu

• Žádná přímá úprava jádra ani cizích rozšíření; vše přes child theme/override/hooky.
• Escapování všech proměnných, nonce/CSRF ochrana ve formulářích.
• Optimalizované assety (minifikace, kombinace, lazy load), korektní registrace v systému.
• Cache a varianty dle jazyka/role; test chování s vypnutou cache.
• i18n pokrytí textů, jazykové soubory a fallbacky.
• Automatizované testy a CI pipeline; verze a changelog.

Závěr

Tvorba vlastních šablon a modulů v CMS vyžaduje pochopení architektury konkrétní platformy, důslednou bezpečnost a disciplinu v oddělení odpovědností. Dodržením principů komponentového návrhu, správného nakládání s assety, přístupnosti a testování docílíte řešení, která jsou výkonná, udržitelná a snadno rozšiřitelná – a přitom plně kompatibilní s aktualizacemi jádra i ekosystému rozšíření.